1{
2    "version": "1.0",
3    "parameters": {
4        "Region": {
5            "builtIn": "AWS::Region",
6            "required": false,
7            "documentation": "The AWS region used to dispatch the request.",
8            "type": "String"
9        },
10        "UseDualStack": {
11            "builtIn": "AWS::UseDualStack",
12            "required": true,
13            "default": false,
14            "documentation": "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.",
15            "type": "Boolean"
16        },
17        "UseFIPS": {
18            "builtIn": "AWS::UseFIPS",
19            "required": true,
20            "default": false,
21            "documentation": "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.",
22            "type": "Boolean"
23        },
24        "Endpoint": {
25            "builtIn": "SDK::Endpoint",
26            "required": false,
27            "documentation": "Override the endpoint used to send this request",
28            "type": "String"
29        },
30        "StreamARN": {
31            "required": false,
32            "documentation": "The ARN of the Kinesis stream",
33            "type": "String"
34        },
35        "OperationType": {
36            "required": false,
37            "documentation": "Internal parameter to distinguish between Control/Data plane API and accordingly generate control/data plane endpoint",
38            "type": "String"
39        },
40        "ConsumerARN": {
41            "required": false,
42            "documentation": "The ARN of the Kinesis consumer",
43            "type": "String"
44        },
45        "ResourceARN": {
46            "required": false,
47            "documentation": "The ARN of the Kinesis resource",
48            "type": "String"
49        }
50    },
51    "rules": [
52        {
53            "conditions": [
54                {
55                    "fn": "isSet",
56                    "argv": [
57                        {
58                            "ref": "StreamARN"
59                        }
60                    ]
61                },
62                {
63                    "fn": "not",
64                    "argv": [
65                        {
66                            "fn": "isSet",
67                            "argv": [
68                                {
69                                    "ref": "Endpoint"
70                                }
71                            ]
72                        }
73                    ]
74                },
75                {
76                    "fn": "isSet",
77                    "argv": [
78                        {
79                            "ref": "Region"
80                        }
81                    ]
82                },
83                {
84                    "fn": "aws.partition",
85                    "argv": [
86                        {
87                            "ref": "Region"
88                        }
89                    ],
90                    "assign": "PartitionResult"
91                },
92                {
93                    "fn": "not",
94                    "argv": [
95                        {
96                            "fn": "stringEquals",
97                            "argv": [
98                                {
99                                    "fn": "getAttr",
100                                    "argv": [
101                                        {
102                                            "ref": "PartitionResult"
103                                        },
104                                        "name"
105                                    ]
106                                },
107                                "aws-iso"
108                            ]
109                        }
110                    ]
111                },
112                {
113                    "fn": "not",
114                    "argv": [
115                        {
116                            "fn": "stringEquals",
117                            "argv": [
118                                {
119                                    "fn": "getAttr",
120                                    "argv": [
121                                        {
122                                            "ref": "PartitionResult"
123                                        },
124                                        "name"
125                                    ]
126                                },
127                                "aws-iso-b"
128                            ]
129                        }
130                    ]
131                }
132            ],
133            "rules": [
134                {
135                    "conditions": [
136                        {
137                            "fn": "aws.parseArn",
138                            "argv": [
139                                {
140                                    "ref": "StreamARN"
141                                }
142                            ],
143                            "assign": "arn"
144                        }
145                    ],
146                    "rules": [
147                        {
148                            "conditions": [
149                                {
150                                    "fn": "isValidHostLabel",
151                                    "argv": [
152                                        {
153                                            "fn": "getAttr",
154                                            "argv": [
155                                                {
156                                                    "ref": "arn"
157                                                },
158                                                "accountId"
159                                            ]
160                                        },
161                                        false
162                                    ]
163                                }
164                            ],
165                            "rules": [
166                                {
167                                    "conditions": [
168                                        {
169                                            "fn": "isValidHostLabel",
170                                            "argv": [
171                                                {
172                                                    "fn": "getAttr",
173                                                    "argv": [
174                                                        {
175                                                            "ref": "arn"
176                                                        },
177                                                        "region"
178                                                    ]
179                                                },
180                                                false
181                                            ]
182                                        }
183                                    ],
184                                    "rules": [
185                                        {
186                                            "conditions": [
187                                                {
188                                                    "fn": "stringEquals",
189                                                    "argv": [
190                                                        {
191                                                            "fn": "getAttr",
192                                                            "argv": [
193                                                                {
194                                                                    "ref": "arn"
195                                                                },
196                                                                "service"
197                                                            ]
198                                                        },
199                                                        "kinesis"
200                                                    ]
201                                                }
202                                            ],
203                                            "rules": [
204                                                {
205                                                    "conditions": [
206                                                        {
207                                                            "fn": "getAttr",
208                                                            "argv": [
209                                                                {
210                                                                    "ref": "arn"
211                                                                },
212                                                                "resourceId[0]"
213                                                            ],
214                                                            "assign": "arnType"
215                                                        },
216                                                        {
217                                                            "fn": "not",
218                                                            "argv": [
219                                                                {
220                                                                    "fn": "stringEquals",
221                                                                    "argv": [
222                                                                        {
223                                                                            "ref": "arnType"
224                                                                        },
225                                                                        ""
226                                                                    ]
227                                                                }
228                                                            ]
229                                                        }
230                                                    ],
231                                                    "rules": [
232                                                        {
233                                                            "conditions": [
234                                                                {
235                                                                    "fn": "stringEquals",
236                                                                    "argv": [
237                                                                        {
238                                                                            "ref": "arnType"
239                                                                        },
240                                                                        "stream"
241                                                                    ]
242                                                                }
243                                                            ],
244                                                            "rules": [
245                                                                {
246                                                                    "conditions": [
247                                                                        {
248                                                                            "fn": "stringEquals",
249                                                                            "argv": [
250                                                                                {
251                                                                                    "fn": "getAttr",
252                                                                                    "argv": [
253                                                                                        {
254                                                                                            "ref": "PartitionResult"
255                                                                                        },
256                                                                                        "name"
257                                                                                    ]
258                                                                                },
259                                                                                "{arn#partition}"
260                                                                            ]
261                                                                        }
262                                                                    ],
263                                                                    "rules": [
264                                                                        {
265                                                                            "conditions": [
266                                                                                {
267                                                                                    "fn": "isSet",
268                                                                                    "argv": [
269                                                                                        {
270                                                                                            "ref": "OperationType"
271                                                                                        }
272                                                                                    ]
273                                                                                }
274                                                                            ],
275                                                                            "rules": [
276                                                                                {
277                                                                                    "conditions": [
278                                                                                        {
279                                                                                            "fn": "booleanEquals",
280                                                                                            "argv": [
281                                                                                                {
282                                                                                                    "ref": "UseFIPS"
283                                                                                                },
284                                                                                                true
285                                                                                            ]
286                                                                                        },
287                                                                                        {
288                                                                                            "fn": "booleanEquals",
289                                                                                            "argv": [
290                                                                                                {
291                                                                                                    "ref": "UseDualStack"
292                                                                                                },
293                                                                                                true
294                                                                                            ]
295                                                                                        }
296                                                                                    ],
297                                                                                    "rules": [
298                                                                                        {
299                                                                                            "conditions": [
300                                                                                                {
301                                                                                                    "fn": "booleanEquals",
302                                                                                                    "argv": [
303                                                                                                        {
304                                                                                                            "fn": "getAttr",
305                                                                                                            "argv": [
306                                                                                                                {
307                                                                                                                    "ref": "PartitionResult"
308                                                                                                                },
309                                                                                                                "supportsFIPS"
310                                                                                                            ]
311                                                                                                        },
312                                                                                                        true
313                                                                                                    ]
314                                                                                                }
315                                                                                            ],
316                                                                                            "rules": [
317                                                                                                {
318                                                                                                    "conditions": [
319                                                                                                        {
320                                                                                                            "fn": "booleanEquals",
321                                                                                                            "argv": [
322                                                                                                                {
323                                                                                                                    "fn": "getAttr",
324                                                                                                                    "argv": [
325                                                                                                                        {
326                                                                                                                            "ref": "PartitionResult"
327                                                                                                                        },
328                                                                                                                        "supportsDualStack"
329                                                                                                                    ]
330                                                                                                                },
331                                                                                                                true
332                                                                                                            ]
333                                                                                                        }
334                                                                                                    ],
335                                                                                                    "rules": [
336                                                                                                        {
337                                                                                                            "conditions": [],
338                                                                                                            "endpoint": {
339                                                                                                                "url": "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
340                                                                                                                "properties": {},
341                                                                                                                "headers": {}
342                                                                                                            },
343                                                                                                            "type": "endpoint"
344                                                                                                        }
345                                                                                                    ],
346                                                                                                    "type": "tree"
347                                                                                                },
348                                                                                                {
349                                                                                                    "conditions": [],
350                                                                                                    "error": "DualStack is enabled, but this partition does not support DualStack.",
351                                                                                                    "type": "error"
352                                                                                                }
353                                                                                            ],
354                                                                                            "type": "tree"
355                                                                                        },
356                                                                                        {
357                                                                                            "conditions": [],
358                                                                                            "error": "FIPS is enabled, but this partition does not support FIPS.",
359                                                                                            "type": "error"
360                                                                                        }
361                                                                                    ],
362                                                                                    "type": "tree"
363                                                                                },
364                                                                                {
365                                                                                    "conditions": [
366                                                                                        {
367                                                                                            "fn": "booleanEquals",
368                                                                                            "argv": [
369                                                                                                {
370                                                                                                    "ref": "UseFIPS"
371                                                                                                },
372                                                                                                true
373                                                                                            ]
374                                                                                        }
375                                                                                    ],
376                                                                                    "rules": [
377                                                                                        {
378                                                                                            "conditions": [
379                                                                                                {
380                                                                                                    "fn": "booleanEquals",
381                                                                                                    "argv": [
382                                                                                                        {
383                                                                                                            "fn": "getAttr",
384                                                                                                            "argv": [
385                                                                                                                {
386                                                                                                                    "ref": "PartitionResult"
387                                                                                                                },
388                                                                                                                "supportsFIPS"
389                                                                                                            ]
390                                                                                                        },
391                                                                                                        true
392                                                                                                    ]
393                                                                                                }
394                                                                                            ],
395                                                                                            "rules": [
396                                                                                                {
397                                                                                                    "conditions": [],
398                                                                                                    "endpoint": {
399                                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dnsSuffix}",
400                                                                                                        "properties": {},
401                                                                                                        "headers": {}
402                                                                                                    },
403                                                                                                    "type": "endpoint"
404                                                                                                }
405                                                                                            ],
406                                                                                            "type": "tree"
407                                                                                        },
408                                                                                        {
409                                                                                            "conditions": [],
410                                                                                            "error": "FIPS is enabled but this partition does not support FIPS",
411                                                                                            "type": "error"
412                                                                                        }
413                                                                                    ],
414                                                                                    "type": "tree"
415                                                                                },
416                                                                                {
417                                                                                    "conditions": [
418                                                                                        {
419                                                                                            "fn": "booleanEquals",
420                                                                                            "argv": [
421                                                                                                {
422                                                                                                    "ref": "UseDualStack"
423                                                                                                },
424                                                                                                true
425                                                                                            ]
426                                                                                        }
427                                                                                    ],
428                                                                                    "rules": [
429                                                                                        {
430                                                                                            "conditions": [
431                                                                                                {
432                                                                                                    "fn": "booleanEquals",
433                                                                                                    "argv": [
434                                                                                                        {
435                                                                                                            "fn": "getAttr",
436                                                                                                            "argv": [
437                                                                                                                {
438                                                                                                                    "ref": "PartitionResult"
439                                                                                                                },
440                                                                                                                "supportsDualStack"
441                                                                                                            ]
442                                                                                                        },
443                                                                                                        true
444                                                                                                    ]
445                                                                                                }
446                                                                                            ],
447                                                                                            "rules": [
448                                                                                                {
449                                                                                                    "conditions": [],
450                                                                                                    "endpoint": {
451                                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dualStackDnsSuffix}",
452                                                                                                        "properties": {},
453                                                                                                        "headers": {}
454                                                                                                    },
455                                                                                                    "type": "endpoint"
456                                                                                                }
457                                                                                            ],
458                                                                                            "type": "tree"
459                                                                                        },
460                                                                                        {
461                                                                                            "conditions": [],
462                                                                                            "error": "DualStack is enabled but this partition does not support DualStack",
463                                                                                            "type": "error"
464                                                                                        }
465                                                                                    ],
466                                                                                    "type": "tree"
467                                                                                },
468                                                                                {
469                                                                                    "conditions": [],
470                                                                                    "endpoint": {
471                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dnsSuffix}",
472                                                                                        "properties": {},
473                                                                                        "headers": {}
474                                                                                    },
475                                                                                    "type": "endpoint"
476                                                                                }
477                                                                            ],
478                                                                            "type": "tree"
479                                                                        },
480                                                                        {
481                                                                            "conditions": [],
482                                                                            "error": "Operation Type is not set. Please contact service team for resolution.",
483                                                                            "type": "error"
484                                                                        }
485                                                                    ],
486                                                                    "type": "tree"
487                                                                },
488                                                                {
489                                                                    "conditions": [],
490                                                                    "error": "Partition: {arn#partition} from ARN doesn't match with partition name: {PartitionResult#name}.",
491                                                                    "type": "error"
492                                                                }
493                                                            ],
494                                                            "type": "tree"
495                                                        },
496                                                        {
497                                                            "conditions": [],
498                                                            "error": "Invalid ARN: Kinesis ARNs don't support `{arnType}` arn types.",
499                                                            "type": "error"
500                                                        }
501                                                    ],
502                                                    "type": "tree"
503                                                },
504                                                {
505                                                    "conditions": [],
506                                                    "error": "Invalid ARN: No ARN type specified",
507                                                    "type": "error"
508                                                }
509                                            ],
510                                            "type": "tree"
511                                        },
512                                        {
513                                            "conditions": [],
514                                            "error": "Invalid ARN: The ARN was not for the Kinesis service, found: {arn#service}.",
515                                            "type": "error"
516                                        }
517                                    ],
518                                    "type": "tree"
519                                },
520                                {
521                                    "conditions": [],
522                                    "error": "Invalid ARN: Invalid region.",
523                                    "type": "error"
524                                }
525                            ],
526                            "type": "tree"
527                        },
528                        {
529                            "conditions": [],
530                            "error": "Invalid ARN: Invalid account id.",
531                            "type": "error"
532                        }
533                    ],
534                    "type": "tree"
535                },
536                {
537                    "conditions": [],
538                    "error": "Invalid ARN: Failed to parse ARN.",
539                    "type": "error"
540                }
541            ],
542            "type": "tree"
543        },
544        {
545            "conditions": [
546                {
547                    "fn": "isSet",
548                    "argv": [
549                        {
550                            "ref": "ConsumerARN"
551                        }
552                    ]
553                },
554                {
555                    "fn": "not",
556                    "argv": [
557                        {
558                            "fn": "isSet",
559                            "argv": [
560                                {
561                                    "ref": "Endpoint"
562                                }
563                            ]
564                        }
565                    ]
566                },
567                {
568                    "fn": "isSet",
569                    "argv": [
570                        {
571                            "ref": "Region"
572                        }
573                    ]
574                },
575                {
576                    "fn": "aws.partition",
577                    "argv": [
578                        {
579                            "ref": "Region"
580                        }
581                    ],
582                    "assign": "PartitionResult"
583                },
584                {
585                    "fn": "not",
586                    "argv": [
587                        {
588                            "fn": "stringEquals",
589                            "argv": [
590                                {
591                                    "fn": "getAttr",
592                                    "argv": [
593                                        {
594                                            "ref": "PartitionResult"
595                                        },
596                                        "name"
597                                    ]
598                                },
599                                "aws-iso"
600                            ]
601                        }
602                    ]
603                },
604                {
605                    "fn": "not",
606                    "argv": [
607                        {
608                            "fn": "stringEquals",
609                            "argv": [
610                                {
611                                    "fn": "getAttr",
612                                    "argv": [
613                                        {
614                                            "ref": "PartitionResult"
615                                        },
616                                        "name"
617                                    ]
618                                },
619                                "aws-iso-b"
620                            ]
621                        }
622                    ]
623                }
624            ],
625            "rules": [
626                {
627                    "conditions": [
628                        {
629                            "fn": "aws.parseArn",
630                            "argv": [
631                                {
632                                    "ref": "ConsumerARN"
633                                }
634                            ],
635                            "assign": "arn"
636                        }
637                    ],
638                    "rules": [
639                        {
640                            "conditions": [
641                                {
642                                    "fn": "isValidHostLabel",
643                                    "argv": [
644                                        {
645                                            "fn": "getAttr",
646                                            "argv": [
647                                                {
648                                                    "ref": "arn"
649                                                },
650                                                "accountId"
651                                            ]
652                                        },
653                                        false
654                                    ]
655                                }
656                            ],
657                            "rules": [
658                                {
659                                    "conditions": [
660                                        {
661                                            "fn": "isValidHostLabel",
662                                            "argv": [
663                                                {
664                                                    "fn": "getAttr",
665                                                    "argv": [
666                                                        {
667                                                            "ref": "arn"
668                                                        },
669                                                        "region"
670                                                    ]
671                                                },
672                                                false
673                                            ]
674                                        }
675                                    ],
676                                    "rules": [
677                                        {
678                                            "conditions": [
679                                                {
680                                                    "fn": "stringEquals",
681                                                    "argv": [
682                                                        {
683                                                            "fn": "getAttr",
684                                                            "argv": [
685                                                                {
686                                                                    "ref": "arn"
687                                                                },
688                                                                "service"
689                                                            ]
690                                                        },
691                                                        "kinesis"
692                                                    ]
693                                                }
694                                            ],
695                                            "rules": [
696                                                {
697                                                    "conditions": [
698                                                        {
699                                                            "fn": "getAttr",
700                                                            "argv": [
701                                                                {
702                                                                    "ref": "arn"
703                                                                },
704                                                                "resourceId[0]"
705                                                            ],
706                                                            "assign": "arnType"
707                                                        },
708                                                        {
709                                                            "fn": "not",
710                                                            "argv": [
711                                                                {
712                                                                    "fn": "stringEquals",
713                                                                    "argv": [
714                                                                        {
715                                                                            "ref": "arnType"
716                                                                        },
717                                                                        ""
718                                                                    ]
719                                                                }
720                                                            ]
721                                                        }
722                                                    ],
723                                                    "rules": [
724                                                        {
725                                                            "conditions": [
726                                                                {
727                                                                    "fn": "stringEquals",
728                                                                    "argv": [
729                                                                        {
730                                                                            "ref": "arnType"
731                                                                        },
732                                                                        "stream"
733                                                                    ]
734                                                                }
735                                                            ],
736                                                            "rules": [
737                                                                {
738                                                                    "conditions": [
739                                                                        {
740                                                                            "fn": "stringEquals",
741                                                                            "argv": [
742                                                                                {
743                                                                                    "fn": "getAttr",
744                                                                                    "argv": [
745                                                                                        {
746                                                                                            "ref": "PartitionResult"
747                                                                                        },
748                                                                                        "name"
749                                                                                    ]
750                                                                                },
751                                                                                "{arn#partition}"
752                                                                            ]
753                                                                        }
754                                                                    ],
755                                                                    "rules": [
756                                                                        {
757                                                                            "conditions": [
758                                                                                {
759                                                                                    "fn": "isSet",
760                                                                                    "argv": [
761                                                                                        {
762                                                                                            "ref": "OperationType"
763                                                                                        }
764                                                                                    ]
765                                                                                }
766                                                                            ],
767                                                                            "rules": [
768                                                                                {
769                                                                                    "conditions": [
770                                                                                        {
771                                                                                            "fn": "booleanEquals",
772                                                                                            "argv": [
773                                                                                                {
774                                                                                                    "ref": "UseFIPS"
775                                                                                                },
776                                                                                                true
777                                                                                            ]
778                                                                                        },
779                                                                                        {
780                                                                                            "fn": "booleanEquals",
781                                                                                            "argv": [
782                                                                                                {
783                                                                                                    "ref": "UseDualStack"
784                                                                                                },
785                                                                                                true
786                                                                                            ]
787                                                                                        }
788                                                                                    ],
789                                                                                    "rules": [
790                                                                                        {
791                                                                                            "conditions": [
792                                                                                                {
793                                                                                                    "fn": "booleanEquals",
794                                                                                                    "argv": [
795                                                                                                        {
796                                                                                                            "fn": "getAttr",
797                                                                                                            "argv": [
798                                                                                                                {
799                                                                                                                    "ref": "PartitionResult"
800                                                                                                                },
801                                                                                                                "supportsFIPS"
802                                                                                                            ]
803                                                                                                        },
804                                                                                                        true
805                                                                                                    ]
806                                                                                                }
807                                                                                            ],
808                                                                                            "rules": [
809                                                                                                {
810                                                                                                    "conditions": [
811                                                                                                        {
812                                                                                                            "fn": "booleanEquals",
813                                                                                                            "argv": [
814                                                                                                                {
815                                                                                                                    "fn": "getAttr",
816                                                                                                                    "argv": [
817                                                                                                                        {
818                                                                                                                            "ref": "PartitionResult"
819                                                                                                                        },
820                                                                                                                        "supportsDualStack"
821                                                                                                                    ]
822                                                                                                                },
823                                                                                                                true
824                                                                                                            ]
825                                                                                                        }
826                                                                                                    ],
827                                                                                                    "rules": [
828                                                                                                        {
829                                                                                                            "conditions": [],
830                                                                                                            "endpoint": {
831                                                                                                                "url": "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
832                                                                                                                "properties": {},
833                                                                                                                "headers": {}
834                                                                                                            },
835                                                                                                            "type": "endpoint"
836                                                                                                        }
837                                                                                                    ],
838                                                                                                    "type": "tree"
839                                                                                                },
840                                                                                                {
841                                                                                                    "conditions": [],
842                                                                                                    "error": "DualStack is enabled, but this partition does not support DualStack.",
843                                                                                                    "type": "error"
844                                                                                                }
845                                                                                            ],
846                                                                                            "type": "tree"
847                                                                                        },
848                                                                                        {
849                                                                                            "conditions": [],
850                                                                                            "error": "FIPS is enabled, but this partition does not support FIPS.",
851                                                                                            "type": "error"
852                                                                                        }
853                                                                                    ],
854                                                                                    "type": "tree"
855                                                                                },
856                                                                                {
857                                                                                    "conditions": [
858                                                                                        {
859                                                                                            "fn": "booleanEquals",
860                                                                                            "argv": [
861                                                                                                {
862                                                                                                    "ref": "UseFIPS"
863                                                                                                },
864                                                                                                true
865                                                                                            ]
866                                                                                        }
867                                                                                    ],
868                                                                                    "rules": [
869                                                                                        {
870                                                                                            "conditions": [
871                                                                                                {
872                                                                                                    "fn": "booleanEquals",
873                                                                                                    "argv": [
874                                                                                                        {
875                                                                                                            "fn": "getAttr",
876                                                                                                            "argv": [
877                                                                                                                {
878                                                                                                                    "ref": "PartitionResult"
879                                                                                                                },
880                                                                                                                "supportsFIPS"
881                                                                                                            ]
882                                                                                                        },
883                                                                                                        true
884                                                                                                    ]
885                                                                                                }
886                                                                                            ],
887                                                                                            "rules": [
888                                                                                                {
889                                                                                                    "conditions": [],
890                                                                                                    "endpoint": {
891                                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dnsSuffix}",
892                                                                                                        "properties": {},
893                                                                                                        "headers": {}
894                                                                                                    },
895                                                                                                    "type": "endpoint"
896                                                                                                }
897                                                                                            ],
898                                                                                            "type": "tree"
899                                                                                        },
900                                                                                        {
901                                                                                            "conditions": [],
902                                                                                            "error": "FIPS is enabled but this partition does not support FIPS",
903                                                                                            "type": "error"
904                                                                                        }
905                                                                                    ],
906                                                                                    "type": "tree"
907                                                                                },
908                                                                                {
909                                                                                    "conditions": [
910                                                                                        {
911                                                                                            "fn": "booleanEquals",
912                                                                                            "argv": [
913                                                                                                {
914                                                                                                    "ref": "UseDualStack"
915                                                                                                },
916                                                                                                true
917                                                                                            ]
918                                                                                        }
919                                                                                    ],
920                                                                                    "rules": [
921                                                                                        {
922                                                                                            "conditions": [
923                                                                                                {
924                                                                                                    "fn": "booleanEquals",
925                                                                                                    "argv": [
926                                                                                                        {
927                                                                                                            "fn": "getAttr",
928                                                                                                            "argv": [
929                                                                                                                {
930                                                                                                                    "ref": "PartitionResult"
931                                                                                                                },
932                                                                                                                "supportsDualStack"
933                                                                                                            ]
934                                                                                                        },
935                                                                                                        true
936                                                                                                    ]
937                                                                                                }
938                                                                                            ],
939                                                                                            "rules": [
940                                                                                                {
941                                                                                                    "conditions": [],
942                                                                                                    "endpoint": {
943                                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dualStackDnsSuffix}",
944                                                                                                        "properties": {},
945                                                                                                        "headers": {}
946                                                                                                    },
947                                                                                                    "type": "endpoint"
948                                                                                                }
949                                                                                            ],
950                                                                                            "type": "tree"
951                                                                                        },
952                                                                                        {
953                                                                                            "conditions": [],
954                                                                                            "error": "DualStack is enabled but this partition does not support DualStack",
955                                                                                            "type": "error"
956                                                                                        }
957                                                                                    ],
958                                                                                    "type": "tree"
959                                                                                },
960                                                                                {
961                                                                                    "conditions": [],
962                                                                                    "endpoint": {
963                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dnsSuffix}",
964                                                                                        "properties": {},
965                                                                                        "headers": {}
966                                                                                    },
967                                                                                    "type": "endpoint"
968                                                                                }
969                                                                            ],
970                                                                            "type": "tree"
971                                                                        },
972                                                                        {
973                                                                            "conditions": [],
974                                                                            "error": "Operation Type is not set. Please contact service team for resolution.",
975                                                                            "type": "error"
976                                                                        }
977                                                                    ],
978                                                                    "type": "tree"
979                                                                },
980                                                                {
981                                                                    "conditions": [],
982                                                                    "error": "Partition: {arn#partition} from ARN doesn't match with partition name: {PartitionResult#name}.",
983                                                                    "type": "error"
984                                                                }
985                                                            ],
986                                                            "type": "tree"
987                                                        },
988                                                        {
989                                                            "conditions": [],
990                                                            "error": "Invalid ARN: Kinesis ARNs don't support `{arnType}` arn types.",
991                                                            "type": "error"
992                                                        }
993                                                    ],
994                                                    "type": "tree"
995                                                },
996                                                {
997                                                    "conditions": [],
998                                                    "error": "Invalid ARN: No ARN type specified",
999                                                    "type": "error"
1000                                                }
1001                                            ],
1002                                            "type": "tree"
1003                                        },
1004                                        {
1005                                            "conditions": [],
1006                                            "error": "Invalid ARN: The ARN was not for the Kinesis service, found: {arn#service}.",
1007                                            "type": "error"
1008                                        }
1009                                    ],
1010                                    "type": "tree"
1011                                },
1012                                {
1013                                    "conditions": [],
1014                                    "error": "Invalid ARN: Invalid region.",
1015                                    "type": "error"
1016                                }
1017                            ],
1018                            "type": "tree"
1019                        },
1020                        {
1021                            "conditions": [],
1022                            "error": "Invalid ARN: Invalid account id.",
1023                            "type": "error"
1024                        }
1025                    ],
1026                    "type": "tree"
1027                },
1028                {
1029                    "conditions": [],
1030                    "error": "Invalid ARN: Failed to parse ARN.",
1031                    "type": "error"
1032                }
1033            ],
1034            "type": "tree"
1035        },
1036        {
1037            "conditions": [
1038                {
1039                    "fn": "isSet",
1040                    "argv": [
1041                        {
1042                            "ref": "ResourceARN"
1043                        }
1044                    ]
1045                },
1046                {
1047                    "fn": "not",
1048                    "argv": [
1049                        {
1050                            "fn": "isSet",
1051                            "argv": [
1052                                {
1053                                    "ref": "Endpoint"
1054                                }
1055                            ]
1056                        }
1057                    ]
1058                },
1059                {
1060                    "fn": "isSet",
1061                    "argv": [
1062                        {
1063                            "ref": "Region"
1064                        }
1065                    ]
1066                },
1067                {
1068                    "fn": "aws.partition",
1069                    "argv": [
1070                        {
1071                            "ref": "Region"
1072                        }
1073                    ],
1074                    "assign": "PartitionResult"
1075                },
1076                {
1077                    "fn": "not",
1078                    "argv": [
1079                        {
1080                            "fn": "stringEquals",
1081                            "argv": [
1082                                {
1083                                    "fn": "getAttr",
1084                                    "argv": [
1085                                        {
1086                                            "ref": "PartitionResult"
1087                                        },
1088                                        "name"
1089                                    ]
1090                                },
1091                                "aws-iso"
1092                            ]
1093                        }
1094                    ]
1095                },
1096                {
1097                    "fn": "not",
1098                    "argv": [
1099                        {
1100                            "fn": "stringEquals",
1101                            "argv": [
1102                                {
1103                                    "fn": "getAttr",
1104                                    "argv": [
1105                                        {
1106                                            "ref": "PartitionResult"
1107                                        },
1108                                        "name"
1109                                    ]
1110                                },
1111                                "aws-iso-b"
1112                            ]
1113                        }
1114                    ]
1115                }
1116            ],
1117            "rules": [
1118                {
1119                    "conditions": [
1120                        {
1121                            "fn": "aws.parseArn",
1122                            "argv": [
1123                                {
1124                                    "ref": "ResourceARN"
1125                                }
1126                            ],
1127                            "assign": "arn"
1128                        }
1129                    ],
1130                    "rules": [
1131                        {
1132                            "conditions": [
1133                                {
1134                                    "fn": "isValidHostLabel",
1135                                    "argv": [
1136                                        {
1137                                            "fn": "getAttr",
1138                                            "argv": [
1139                                                {
1140                                                    "ref": "arn"
1141                                                },
1142                                                "accountId"
1143                                            ]
1144                                        },
1145                                        false
1146                                    ]
1147                                }
1148                            ],
1149                            "rules": [
1150                                {
1151                                    "conditions": [
1152                                        {
1153                                            "fn": "isValidHostLabel",
1154                                            "argv": [
1155                                                {
1156                                                    "fn": "getAttr",
1157                                                    "argv": [
1158                                                        {
1159                                                            "ref": "arn"
1160                                                        },
1161                                                        "region"
1162                                                    ]
1163                                                },
1164                                                false
1165                                            ]
1166                                        }
1167                                    ],
1168                                    "rules": [
1169                                        {
1170                                            "conditions": [
1171                                                {
1172                                                    "fn": "stringEquals",
1173                                                    "argv": [
1174                                                        {
1175                                                            "fn": "getAttr",
1176                                                            "argv": [
1177                                                                {
1178                                                                    "ref": "arn"
1179                                                                },
1180                                                                "service"
1181                                                            ]
1182                                                        },
1183                                                        "kinesis"
1184                                                    ]
1185                                                }
1186                                            ],
1187                                            "rules": [
1188                                                {
1189                                                    "conditions": [
1190                                                        {
1191                                                            "fn": "getAttr",
1192                                                            "argv": [
1193                                                                {
1194                                                                    "ref": "arn"
1195                                                                },
1196                                                                "resourceId[0]"
1197                                                            ],
1198                                                            "assign": "arnType"
1199                                                        },
1200                                                        {
1201                                                            "fn": "not",
1202                                                            "argv": [
1203                                                                {
1204                                                                    "fn": "stringEquals",
1205                                                                    "argv": [
1206                                                                        {
1207                                                                            "ref": "arnType"
1208                                                                        },
1209                                                                        ""
1210                                                                    ]
1211                                                                }
1212                                                            ]
1213                                                        }
1214                                                    ],
1215                                                    "rules": [
1216                                                        {
1217                                                            "conditions": [
1218                                                                {
1219                                                                    "fn": "stringEquals",
1220                                                                    "argv": [
1221                                                                        {
1222                                                                            "ref": "arnType"
1223                                                                        },
1224                                                                        "stream"
1225                                                                    ]
1226                                                                }
1227                                                            ],
1228                                                            "rules": [
1229                                                                {
1230                                                                    "conditions": [
1231                                                                        {
1232                                                                            "fn": "stringEquals",
1233                                                                            "argv": [
1234                                                                                {
1235                                                                                    "fn": "getAttr",
1236                                                                                    "argv": [
1237                                                                                        {
1238                                                                                            "ref": "PartitionResult"
1239                                                                                        },
1240                                                                                        "name"
1241                                                                                    ]
1242                                                                                },
1243                                                                                "{arn#partition}"
1244                                                                            ]
1245                                                                        }
1246                                                                    ],
1247                                                                    "rules": [
1248                                                                        {
1249                                                                            "conditions": [
1250                                                                                {
1251                                                                                    "fn": "isSet",
1252                                                                                    "argv": [
1253                                                                                        {
1254                                                                                            "ref": "OperationType"
1255                                                                                        }
1256                                                                                    ]
1257                                                                                }
1258                                                                            ],
1259                                                                            "rules": [
1260                                                                                {
1261                                                                                    "conditions": [
1262                                                                                        {
1263                                                                                            "fn": "booleanEquals",
1264                                                                                            "argv": [
1265                                                                                                {
1266                                                                                                    "ref": "UseFIPS"
1267                                                                                                },
1268                                                                                                true
1269                                                                                            ]
1270                                                                                        },
1271                                                                                        {
1272                                                                                            "fn": "booleanEquals",
1273                                                                                            "argv": [
1274                                                                                                {
1275                                                                                                    "ref": "UseDualStack"
1276                                                                                                },
1277                                                                                                true
1278                                                                                            ]
1279                                                                                        }
1280                                                                                    ],
1281                                                                                    "rules": [
1282                                                                                        {
1283                                                                                            "conditions": [
1284                                                                                                {
1285                                                                                                    "fn": "booleanEquals",
1286                                                                                                    "argv": [
1287                                                                                                        {
1288                                                                                                            "fn": "getAttr",
1289                                                                                                            "argv": [
1290                                                                                                                {
1291                                                                                                                    "ref": "PartitionResult"
1292                                                                                                                },
1293                                                                                                                "supportsFIPS"
1294                                                                                                            ]
1295                                                                                                        },
1296                                                                                                        true
1297                                                                                                    ]
1298                                                                                                }
1299                                                                                            ],
1300                                                                                            "rules": [
1301                                                                                                {
1302                                                                                                    "conditions": [
1303                                                                                                        {
1304                                                                                                            "fn": "booleanEquals",
1305                                                                                                            "argv": [
1306                                                                                                                {
1307                                                                                                                    "fn": "getAttr",
1308                                                                                                                    "argv": [
1309                                                                                                                        {
1310                                                                                                                            "ref": "PartitionResult"
1311                                                                                                                        },
1312                                                                                                                        "supportsDualStack"
1313                                                                                                                    ]
1314                                                                                                                },
1315                                                                                                                true
1316                                                                                                            ]
1317                                                                                                        }
1318                                                                                                    ],
1319                                                                                                    "rules": [
1320                                                                                                        {
1321                                                                                                            "conditions": [],
1322                                                                                                            "endpoint": {
1323                                                                                                                "url": "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
1324                                                                                                                "properties": {},
1325                                                                                                                "headers": {}
1326                                                                                                            },
1327                                                                                                            "type": "endpoint"
1328                                                                                                        }
1329                                                                                                    ],
1330                                                                                                    "type": "tree"
1331                                                                                                },
1332                                                                                                {
1333                                                                                                    "conditions": [],
1334                                                                                                    "error": "DualStack is enabled, but this partition does not support DualStack.",
1335                                                                                                    "type": "error"
1336                                                                                                }
1337                                                                                            ],
1338                                                                                            "type": "tree"
1339                                                                                        },
1340                                                                                        {
1341                                                                                            "conditions": [],
1342                                                                                            "error": "FIPS is enabled, but this partition does not support FIPS.",
1343                                                                                            "type": "error"
1344                                                                                        }
1345                                                                                    ],
1346                                                                                    "type": "tree"
1347                                                                                },
1348                                                                                {
1349                                                                                    "conditions": [
1350                                                                                        {
1351                                                                                            "fn": "booleanEquals",
1352                                                                                            "argv": [
1353                                                                                                {
1354                                                                                                    "ref": "UseFIPS"
1355                                                                                                },
1356                                                                                                true
1357                                                                                            ]
1358                                                                                        }
1359                                                                                    ],
1360                                                                                    "rules": [
1361                                                                                        {
1362                                                                                            "conditions": [
1363                                                                                                {
1364                                                                                                    "fn": "booleanEquals",
1365                                                                                                    "argv": [
1366                                                                                                        {
1367                                                                                                            "fn": "getAttr",
1368                                                                                                            "argv": [
1369                                                                                                                {
1370                                                                                                                    "ref": "PartitionResult"
1371                                                                                                                },
1372                                                                                                                "supportsFIPS"
1373                                                                                                            ]
1374                                                                                                        },
1375                                                                                                        true
1376                                                                                                    ]
1377                                                                                                }
1378                                                                                            ],
1379                                                                                            "rules": [
1380                                                                                                {
1381                                                                                                    "conditions": [],
1382                                                                                                    "endpoint": {
1383                                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis-fips.{Region}.{PartitionResult#dnsSuffix}",
1384                                                                                                        "properties": {},
1385                                                                                                        "headers": {}
1386                                                                                                    },
1387                                                                                                    "type": "endpoint"
1388                                                                                                }
1389                                                                                            ],
1390                                                                                            "type": "tree"
1391                                                                                        },
1392                                                                                        {
1393                                                                                            "conditions": [],
1394                                                                                            "error": "FIPS is enabled but this partition does not support FIPS",
1395                                                                                            "type": "error"
1396                                                                                        }
1397                                                                                    ],
1398                                                                                    "type": "tree"
1399                                                                                },
1400                                                                                {
1401                                                                                    "conditions": [
1402                                                                                        {
1403                                                                                            "fn": "booleanEquals",
1404                                                                                            "argv": [
1405                                                                                                {
1406                                                                                                    "ref": "UseDualStack"
1407                                                                                                },
1408                                                                                                true
1409                                                                                            ]
1410                                                                                        }
1411                                                                                    ],
1412                                                                                    "rules": [
1413                                                                                        {
1414                                                                                            "conditions": [
1415                                                                                                {
1416                                                                                                    "fn": "booleanEquals",
1417                                                                                                    "argv": [
1418                                                                                                        {
1419                                                                                                            "fn": "getAttr",
1420                                                                                                            "argv": [
1421                                                                                                                {
1422                                                                                                                    "ref": "PartitionResult"
1423                                                                                                                },
1424                                                                                                                "supportsDualStack"
1425                                                                                                            ]
1426                                                                                                        },
1427                                                                                                        true
1428                                                                                                    ]
1429                                                                                                }
1430                                                                                            ],
1431                                                                                            "rules": [
1432                                                                                                {
1433                                                                                                    "conditions": [],
1434                                                                                                    "endpoint": {
1435                                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dualStackDnsSuffix}",
1436                                                                                                        "properties": {},
1437                                                                                                        "headers": {}
1438                                                                                                    },
1439                                                                                                    "type": "endpoint"
1440                                                                                                }
1441                                                                                            ],
1442                                                                                            "type": "tree"
1443                                                                                        },
1444                                                                                        {
1445                                                                                            "conditions": [],
1446                                                                                            "error": "DualStack is enabled but this partition does not support DualStack",
1447                                                                                            "type": "error"
1448                                                                                        }
1449                                                                                    ],
1450                                                                                    "type": "tree"
1451                                                                                },
1452                                                                                {
1453                                                                                    "conditions": [],
1454                                                                                    "endpoint": {
1455                                                                                        "url": "https://{arn#accountId}.{OperationType}-kinesis.{Region}.{PartitionResult#dnsSuffix}",
1456                                                                                        "properties": {},
1457                                                                                        "headers": {}
1458                                                                                    },
1459                                                                                    "type": "endpoint"
1460                                                                                }
1461                                                                            ],
1462                                                                            "type": "tree"
1463                                                                        },
1464                                                                        {
1465                                                                            "conditions": [],
1466                                                                            "error": "Operation Type is not set. Please contact service team for resolution.",
1467                                                                            "type": "error"
1468                                                                        }
1469                                                                    ],
1470                                                                    "type": "tree"
1471                                                                },
1472                                                                {
1473                                                                    "conditions": [],
1474                                                                    "error": "Partition: {arn#partition} from ARN doesn't match with partition name: {PartitionResult#name}.",
1475                                                                    "type": "error"
1476                                                                }
1477                                                            ],
1478                                                            "type": "tree"
1479                                                        },
1480                                                        {
1481                                                            "conditions": [],
1482                                                            "error": "Invalid ARN: Kinesis ARNs don't support `{arnType}` arn types.",
1483                                                            "type": "error"
1484                                                        }
1485                                                    ],
1486                                                    "type": "tree"
1487                                                },
1488                                                {
1489                                                    "conditions": [],
1490                                                    "error": "Invalid ARN: No ARN type specified",
1491                                                    "type": "error"
1492                                                }
1493                                            ],
1494                                            "type": "tree"
1495                                        },
1496                                        {
1497                                            "conditions": [],
1498                                            "error": "Invalid ARN: The ARN was not for the Kinesis service, found: {arn#service}.",
1499                                            "type": "error"
1500                                        }
1501                                    ],
1502                                    "type": "tree"
1503                                },
1504                                {
1505                                    "conditions": [],
1506                                    "error": "Invalid ARN: Invalid region.",
1507                                    "type": "error"
1508                                }
1509                            ],
1510                            "type": "tree"
1511                        },
1512                        {
1513                            "conditions": [],
1514                            "error": "Invalid ARN: Invalid account id.",
1515                            "type": "error"
1516                        }
1517                    ],
1518                    "type": "tree"
1519                },
1520                {
1521                    "conditions": [],
1522                    "error": "Invalid ARN: Failed to parse ARN.",
1523                    "type": "error"
1524                }
1525            ],
1526            "type": "tree"
1527        },
1528        {
1529            "conditions": [
1530                {
1531                    "fn": "isSet",
1532                    "argv": [
1533                        {
1534                            "ref": "Endpoint"
1535                        }
1536                    ]
1537                }
1538            ],
1539            "rules": [
1540                {
1541                    "conditions": [
1542                        {
1543                            "fn": "booleanEquals",
1544                            "argv": [
1545                                {
1546                                    "ref": "UseFIPS"
1547                                },
1548                                true
1549                            ]
1550                        }
1551                    ],
1552                    "error": "Invalid Configuration: FIPS and custom endpoint are not supported",
1553                    "type": "error"
1554                },
1555                {
1556                    "conditions": [
1557                        {
1558                            "fn": "booleanEquals",
1559                            "argv": [
1560                                {
1561                                    "ref": "UseDualStack"
1562                                },
1563                                true
1564                            ]
1565                        }
1566                    ],
1567                    "error": "Invalid Configuration: Dualstack and custom endpoint are not supported",
1568                    "type": "error"
1569                },
1570                {
1571                    "conditions": [],
1572                    "endpoint": {
1573                        "url": {
1574                            "ref": "Endpoint"
1575                        },
1576                        "properties": {},
1577                        "headers": {}
1578                    },
1579                    "type": "endpoint"
1580                }
1581            ],
1582            "type": "tree"
1583        },
1584        {
1585            "conditions": [
1586                {
1587                    "fn": "isSet",
1588                    "argv": [
1589                        {
1590                            "ref": "Region"
1591                        }
1592                    ]
1593                }
1594            ],
1595            "rules": [
1596                {
1597                    "conditions": [
1598                        {
1599                            "fn": "aws.partition",
1600                            "argv": [
1601                                {
1602                                    "ref": "Region"
1603                                }
1604                            ],
1605                            "assign": "PartitionResult"
1606                        }
1607                    ],
1608                    "rules": [
1609                        {
1610                            "conditions": [
1611                                {
1612                                    "fn": "booleanEquals",
1613                                    "argv": [
1614                                        {
1615                                            "ref": "UseFIPS"
1616                                        },
1617                                        true
1618                                    ]
1619                                },
1620                                {
1621                                    "fn": "booleanEquals",
1622                                    "argv": [
1623                                        {
1624                                            "ref": "UseDualStack"
1625                                        },
1626                                        true
1627                                    ]
1628                                }
1629                            ],
1630                            "rules": [
1631                                {
1632                                    "conditions": [
1633                                        {
1634                                            "fn": "booleanEquals",
1635                                            "argv": [
1636                                                true,
1637                                                {
1638                                                    "fn": "getAttr",
1639                                                    "argv": [
1640                                                        {
1641                                                            "ref": "PartitionResult"
1642                                                        },
1643                                                        "supportsFIPS"
1644                                                    ]
1645                                                }
1646                                            ]
1647                                        },
1648                                        {
1649                                            "fn": "booleanEquals",
1650                                            "argv": [
1651                                                true,
1652                                                {
1653                                                    "fn": "getAttr",
1654                                                    "argv": [
1655                                                        {
1656                                                            "ref": "PartitionResult"
1657                                                        },
1658                                                        "supportsDualStack"
1659                                                    ]
1660                                                }
1661                                            ]
1662                                        }
1663                                    ],
1664                                    "rules": [
1665                                        {
1666                                            "conditions": [],
1667                                            "endpoint": {
1668                                                "url": "https://kinesis-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
1669                                                "properties": {},
1670                                                "headers": {}
1671                                            },
1672                                            "type": "endpoint"
1673                                        }
1674                                    ],
1675                                    "type": "tree"
1676                                },
1677                                {
1678                                    "conditions": [],
1679                                    "error": "FIPS and DualStack are enabled, but this partition does not support one or both",
1680                                    "type": "error"
1681                                }
1682                            ],
1683                            "type": "tree"
1684                        },
1685                        {
1686                            "conditions": [
1687                                {
1688                                    "fn": "booleanEquals",
1689                                    "argv": [
1690                                        {
1691                                            "ref": "UseFIPS"
1692                                        },
1693                                        true
1694                                    ]
1695                                }
1696                            ],
1697                            "rules": [
1698                                {
1699                                    "conditions": [
1700                                        {
1701                                            "fn": "booleanEquals",
1702                                            "argv": [
1703                                                {
1704                                                    "fn": "getAttr",
1705                                                    "argv": [
1706                                                        {
1707                                                            "ref": "PartitionResult"
1708                                                        },
1709                                                        "supportsFIPS"
1710                                                    ]
1711                                                },
1712                                                true
1713                                            ]
1714                                        }
1715                                    ],
1716                                    "rules": [
1717                                        {
1718                                            "conditions": [
1719                                                {
1720                                                    "fn": "stringEquals",
1721                                                    "argv": [
1722                                                        {
1723                                                            "fn": "getAttr",
1724                                                            "argv": [
1725                                                                {
1726                                                                    "ref": "PartitionResult"
1727                                                                },
1728                                                                "name"
1729                                                            ]
1730                                                        },
1731                                                        "aws-us-gov"
1732                                                    ]
1733                                                }
1734                                            ],
1735                                            "endpoint": {
1736                                                "url": "https://kinesis.{Region}.amazonaws.com",
1737                                                "properties": {},
1738                                                "headers": {}
1739                                            },
1740                                            "type": "endpoint"
1741                                        },
1742                                        {
1743                                            "conditions": [],
1744                                            "endpoint": {
1745                                                "url": "https://kinesis-fips.{Region}.{PartitionResult#dnsSuffix}",
1746                                                "properties": {},
1747                                                "headers": {}
1748                                            },
1749                                            "type": "endpoint"
1750                                        }
1751                                    ],
1752                                    "type": "tree"
1753                                },
1754                                {
1755                                    "conditions": [],
1756                                    "error": "FIPS is enabled but this partition does not support FIPS",
1757                                    "type": "error"
1758                                }
1759                            ],
1760                            "type": "tree"
1761                        },
1762                        {
1763                            "conditions": [
1764                                {
1765                                    "fn": "booleanEquals",
1766                                    "argv": [
1767                                        {
1768                                            "ref": "UseDualStack"
1769                                        },
1770                                        true
1771                                    ]
1772                                }
1773                            ],
1774                            "rules": [
1775                                {
1776                                    "conditions": [
1777                                        {
1778                                            "fn": "booleanEquals",
1779                                            "argv": [
1780                                                true,
1781                                                {
1782                                                    "fn": "getAttr",
1783                                                    "argv": [
1784                                                        {
1785                                                            "ref": "PartitionResult"
1786                                                        },
1787                                                        "supportsDualStack"
1788                                                    ]
1789                                                }
1790                                            ]
1791                                        }
1792                                    ],
1793                                    "rules": [
1794                                        {
1795                                            "conditions": [],
1796                                            "endpoint": {
1797                                                "url": "https://kinesis.{Region}.{PartitionResult#dualStackDnsSuffix}",
1798                                                "properties": {},
1799                                                "headers": {}
1800                                            },
1801                                            "type": "endpoint"
1802                                        }
1803                                    ],
1804                                    "type": "tree"
1805                                },
1806                                {
1807                                    "conditions": [],
1808                                    "error": "DualStack is enabled but this partition does not support DualStack",
1809                                    "type": "error"
1810                                }
1811                            ],
1812                            "type": "tree"
1813                        },
1814                        {
1815                            "conditions": [],
1816                            "endpoint": {
1817                                "url": "https://kinesis.{Region}.{PartitionResult#dnsSuffix}",
1818                                "properties": {},
1819                                "headers": {}
1820                            },
1821                            "type": "endpoint"
1822                        }
1823                    ],
1824                    "type": "tree"
1825                }
1826            ],
1827            "type": "tree"
1828        },
1829        {
1830            "conditions": [],
1831            "error": "Invalid Configuration: Missing Region",
1832            "type": "error"
1833        }
1834    ]
1835}