@horietakehiro/aws-cdk-utul 0.35.6 → 0.40.1

package/lib/assertions.js

@@ -199,7 +199,7 @@ exports.TypedTemplate = TypedTemplate;
 /**
  * provides some syntax sugars for `Match` class at `aws-cdk-lib/assertions`
  */
-class ExtraMatch extends assertions_1.Match {
+class ExtraMatch {
     /**
      * same function as `Match.objectEquals({ Ref: logicalId })`
      * @param logicalId
@@ -225,24 +225,6 @@ class ExtraMatch extends assertions_1.Match {
     static getAttArn(logicalId) {
         return this.getAtt(logicalId, "Arn");
     }
-    static arrayWith(pattern) {
-        return assertions_1.Match.arrayWith(pattern);
-    }
-    static arrayEquals(pattern) {
-        return assertions_1.Match.arrayEquals(pattern);
-    }
-    static objectLike(pattern) {
-        return assertions_1.Match.objectLike(pattern);
-    }
-    static objectEquals(pattern) {
-        return assertions_1.Match.objectEquals(pattern);
-    }
-    static not(pattern) {
-        return assertions_1.Match.not(pattern);
-    }
-    static exact(pattern) {
-        return assertions_1.Match.exact(pattern);
-    }
     /**
      * same function as below:
      *
@@ -259,55 +241,235 @@ class ExtraMatch extends assertions_1.Match {
             "Fn::Join": [props.delimiter ?? "", assertions_1.Match.arrayWith(props.arrayWith)],
         });
     }
-    // /**
-    //  * returns Match instance that matches regional resource ARN like : `arn:aws:logs:ap-northeast-1:123456789012:log-group:/log-group-name:log-stream:log-stream-name`
-    //  * @param elems
-    //  * @returns
-    //  */
-    // static regionalArnLike(elems: AlsoMatcher<ArnElements>): Matcher {
-    //   return Match.objectEquals({
-    //     "Fn::Join": Match.arrayWith([
-    //       "",
-    //       Match.arrayWith([
-    //         "arn:",
-    //         elems.partition ?? { Ref: "AWS::Partition" },
-    //         Match.stringLikeRegexp(`:${elems.service ?? "*"}:`),
-    //         elems.region ?? { Ref: "AWS::Region" },
-    //         elems.account ?? { Ref: "AWS::AccountId" },
-    //         ...(elems.rest instanceof Matcher
-    //           ? [elems.rest]
-    //           : (elems.rest ?? [])),
-    //       ]),
-    //     ]),
-    //   });
-    // }
-    // /**
-    //  * returns Match instance that matches global resource ARN like : `arn:aws:iam::123456789012:role/role-name`
-    //  * @param elems
-    //  * @returns
-    //  */
-    // static globalArn(
-    //   elems: Omit<ArnElements, "region">,
-    //   delimiter: string = ""
-    // ): Matcher {
-    //   return Match.objectEquals({
-    //     "Fn::Join": Match.arrayEquals([
-    //       delimiter,
-    //       Match.arrayWith([
-    //         "arn:",
-    //         elems.partition ?? { Ref: "AWS::Partition" },
-    //         Match.stringLikeRegexp(`:${elems.service ?? "*"}::`),
-    //         elems.account ?? { Ref: "AWS::AccountId" },
-    //         ...(elems.rest instanceof Matcher
-    //           ? [elems.rest]
-    //           : (elems.rest ?? [])),
-    //       ]),
-    //     ]),
-    //   });
-    // }
+    /**
+     You can define Matcher for IAM Policy Document with type hints.
+     ```js
+      template.hasResource(
+        AWS_IAM_ROLE({
+          Properties: {
+            AssumeRolePolicyDocument: ExtraMatch.iamPolicyLike({
+              Statement: [
+                {
+                  Principal: { Service: "ec2.amazonaws.com" },
+                },
+              ],
+            }),
+          },
+        })
+      );
+     ```
+     * @param doc
+     * @returns
+     */
     static iamPolicyLike(doc) {
         return assertions_1.Match.objectLike(doc);
     }
+    /**
+     Same method as `Match.arrayWith` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              {
+                Key: "key2",
+                Value: "val2",
+              },
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<string[]>([
+              "hoge", "fuga"
+            ]),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static arrayWith(pattern) {
+        return assertions_1.Match.arrayWith(pattern);
+    }
+    /**
+     * Same method as `Match.arrayEquals` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayEquals<Tag[]>([
+              {
+                Key: "key1",
+                Value: "val1",
+              },
+              {
+                Key: "key2",
+                Value: "val2",
+              },
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayEquals<Tag[]>([
+              {
+                Key: "key1",
+                Value: "val1",
+              },
+              {
+                Key: 100,
+                Value: 200,
+              },
+            ]),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static arrayEquals(pattern) {
+        return assertions_1.Match.arrayEquals(pattern);
+    }
+    /**
+     * Same method as `Match.objectLike` but provides type hints and validate type match
+     ```js
+     // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            BlockDeviceMappings: [
+              {
+                DeviceName: "test",
+                Ebs: ExtraMatch.objectLike<Ebs>({
+                  VolumeSize: 10,
+                }),
+              },
+            ],
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            BlockDeviceMappings: [
+              {
+                DeviceName: "test",
+                Ebs: ExtraMatch.objectLike<Ebs>({
+                  VolumeSize: "10",
+                }),
+              },
+            ],
+          },
+        })
+      );
+     * @param pattern
+     * @returns
+     */
+    static objectLike(pattern) {
+        return assertions_1.Match.objectLike(pattern);
+    }
+    /**
+     * Same method as `Match.objectEquals` but provides type hints and validate type match
+     ```js
+     // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            // You can nest TypedMatcher(use TypedMatcher inside TypedMatcher)
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              ExtraMatch.objectEquals<Tag>({
+                Key: "key1",
+                Value: "val1",
+              }),
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              ExtraMatch.objectEquals<Tag>({
+                Key: "key1",
+                Value: 100,
+              }),
+            ]),
+          },
+        })
+      );
+     * @param pattern
+     * @returns
+     */
+    static objectEquals(pattern) {
+        return assertions_1.Match.objectEquals(pattern);
+    }
+    /**
+     * Same method as `Match.not` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            ImageId: ExtraMatch.not("ami-12345"),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            ImageId: ExtraMatch.not(100),
+          },
+        })
+      );
+     ```
+     * Same method as `Match.not` but provides type hints and validate type match
+     * @param pattern
+     * @returns
+     */
+    // TODO: why this expression `T extends never ? never : T` is required but this is required
+    static not(pattern) {
+        return assertions_1.Match.not(pattern);
+    }
+    /**
+     * Same method as `Match.exact` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            InstanceType: ExtraMatch.exact("t2.micro"),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            InstanceType: ExtraMatch.exact(false),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static exact(pattern) {
+        return assertions_1.Match.exact(pattern);
+    }
 }
 exports.ExtraMatch = ExtraMatch;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assertions.js","sourceRoot":"","sources":["assertions.ts"],"names":[],"mappings":";;;AAAA,uDAAkE;AAiBlE;;GAEG;AACH,MAAa,aAAa;IAExB,YAAoB,QAAkB;QACpC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAEO,GAAG,CAAI,IAAY,EAAE,GAAQ,EAAE,KAAU;QAC/C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,KAAK,CAAC,GAAG,IAAI,gCAAgC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC5E,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,KAAK,CACT,YAAY,IAAI,4BAA4B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,SAAS,CACd,GAAG,IAA2C;QAE9C,OAAO,IAAI,aAAa,CAAC,qBAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACxD,CAAC;IACD;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CACb,GAAG,IAA0C;QAE7C,OAAO,IAAI,aAAa,CAAC,qBAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACvD,CAAC;IACD;;;;OAIG;IACH,MAAM,CAAC,UAAU,CACf,GAAG,IAA4C;QAE/C,OAAO,IAAI,aAAa,CAAC,qBAAQ,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACzD,CAAC;IAED;;;;;;;;;;OAUG;IACH,eAAe,CACb,IAAkE,EAClE,KAAa;QAEb,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;IACD;;;;OAIG;IACH,yBAAyB,CAAI,CAAmB,EAAE,KAAa;QAC7D,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACvE,CAAC;IACD;;;OAGG;IACH,qBAAqB,CAAI,CAAmB;QAC1C,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;IAC5D,CAAC;IACD;;;OAGG;IACH,WAAW,CAAI,CAAmB;QAChC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACvC,CAAC;IACD;;;;OAIG;IACH,aAAa,CAAI,CAAmB;QAClC,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAEtD,CAAC;QACF,OAAO,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,EAAE;YACtD,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;QACnC,CAAC,CAAC,CAAC;IACL,CAAC;IACD;;;OAGG;IACH,YAAY,CAAI,CAAmB;QACjC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACxC,CAAC;IACD;;;OAGG;IACH,sBAAsB,CAAI,CAAmB;QAC3C,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;IAC7D,CAAC;IACD;;;;OAIG;IACH,YAAY,CAAC,SAAiB,EAAE,KAAoB;QAClD,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;IACD;;;;;OAKG;IACH,cAAc,CACZ,SAAiB,EACjB,KAAqB;QAErB,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAClE,OAAO,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE;YACxD,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,SAA4B,EAAE,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,SAAiB,EAAE,KAAkB;QAC7C,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IACD;;;;;OAKG;IACH,WAAW,CACT,SAAiB,EACjB,KAAmB;QAEnB,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAC5D,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE;YAClD,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,MAAsB,EAAE,CAAC;QACjD,CAAC,CAAC,CAAC;IACL,CAAC;IACD;;;;OAIG;IACH,UAAU,CAAC,SAAiB,EAAE,KAAU;QACtC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;IACD;;;;;OAKG;IACH,YAAY,CAAC,SAAiB,EAAE,KAAW;QACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAC9D,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE;YACpD,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC;QAClC,CAAC,CAAC,CAAC;IACL,CAAC;IACD;;;;OAIG;IACH,YAAY,CAAC,SAAiB,EAAE,KAAU;QACxC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;IACD;;;;;OAKG;IACH,cAAc,CAAC,SAAiB,EAAE,KAAW;QAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAClE,OAAO,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE;YACxD,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;QACpC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,WAAW,CACT,GAAG,IAA8C;QAEjD,OAAO,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpE,CAAC;CACF;AAxND,sCAwNC;AASD;;GAEG;AACH,MAAa,UAAW,SAAQ,kBAAK;IACnC;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,SAAiB;QAC1B,OAAO,kBAAK,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC;IAChD,CAAC;IACD;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,SAAiB,EAAE,SAAiB;QAChD,OAAO,kBAAK,CAAC,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;IACtE,CAAC;IACD;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,SAAiB;QAChC,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC;IAED,MAAM,CAAC,SAAS,CAAkB,OAAuB;QACvD,OAAO,kBAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IACD,MAAM,CAAC,WAAW,CAChB,OAAuB;QAEvB,OAAO,kBAAK,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IACD,MAAM,CAAC,UAAU,CACf,OAAuB;QAEvB,OAAO,kBAAK,CAAC,UAAU,CAAC,OAAO,CAAoB,CAAC;IACtD,CAAC;IACD,MAAM,CAAC,YAAY,CACjB,OAAuB;QAEvB,OAAO,kBAAK,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IACD,MAAM,CAAC,GAAG,CAAI,OAAuB;QACnC,OAAO,kBAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IACD,MAAM,CAAC,KAAK,CAAI,OAAuB;QACrC,OAAO,kBAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAC,QAAQ,CAAC,KAAgB;QAC9B,OAAO,kBAAK,CAAC,UAAU,CAAC;YACtB,UAAU,EAAE,CAAC,KAAK,CAAC,SAAS,IAAI,EAAE,EAAE,kBAAK,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;SACtE,CAAC,CAAC;IACL,CAAC;IAED,MAAM;IACN,sKAAsK;IACtK,kBAAkB;IAClB,cAAc;IACd,MAAM;IACN,qEAAqE;IACrE,gCAAgC;IAChC,oCAAoC;IACpC,YAAY;IACZ,0BAA0B;IAC1B,kBAAkB;IAClB,wDAAwD;IACxD,+DAA+D;IAC/D,kDAAkD;IAClD,sDAAsD;IACtD,4CAA4C;IAC5C,2BAA2B;IAC3B,mCAAmC;IACnC,YAAY;IACZ,UAAU;IACV,QAAQ;IACR,IAAI;IAEJ,MAAM;IACN,+GAA+G;IAC/G,kBAAkB;IAClB,cAAc;IACd,MAAM;IACN,oBAAoB;IACpB,wCAAwC;IACxC,2BAA2B;IAC3B,eAAe;IACf,gCAAgC;IAChC,sCAAsC;IACtC,mBAAmB;IACnB,0BAA0B;IAC1B,kBAAkB;IAClB,wDAAwD;IACxD,gEAAgE;IAChE,sDAAsD;IACtD,4CAA4C;IAC5C,2BAA2B;IAC3B,mCAAmC;IACnC,YAAY;IACZ,UAAU;IACV,QAAQ;IACR,IAAI;IAEJ,MAAM,CAAC,aAAa,CAAC,GAAmC;QACtD,OAAO,kBAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC;CACF;AAxHD,gCAwHC","sourcesContent":["import { Template, Match, Matcher } from \"aws-cdk-lib/assertions\";\nimport {\n  Condition,\n  InputResource,\n  Mapping,\n  OutputResource,\n  InputParamter,\n  OutputParameter,\n  ReturnValue,\n  InputOutput,\n  OutputOutput,\n  InputResourceWithoutType,\n  IAMPolicyDocument,\n  AlsoMatcher,\n  TypedMatcher,\n} from \"./typed-resource\";\n\n/**\n * almost same class as `Template` class at \"aws-cdk-lib/assertions\", but you can use this with proper type definitions\n */\nexport class TypedTemplate {\n  template: Template;\n  private constructor(template: Template) {\n    this.template = template;\n  }\n\n  private get<T>(type: string, def: any, array: T[]): T {\n    if (array.length === 0) {\n      throw Error(`${type} not found with definition : ${JSON.stringify(def)}`);\n    }\n    if (array.length > 1) {\n      throw Error(\n        `multiple ${type} found with definition : ${JSON.stringify(def)}`\n      );\n    }\n    return array[0];\n  }\n\n  /**\n   * same function as `Template.fromStack` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromStack(\n    ...args: Parameters<typeof Template.fromStack>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromStack(...args));\n  }\n  /**\n   * same function as `Template.fromJSON` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromJSON(\n    ...args: Parameters<typeof Template.fromJSON>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromJSON(...args));\n  }\n  /**\n   * same function as `Template.fromString` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromString(\n    ...args: Parameters<typeof Template.fromString>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromString(...args));\n  }\n\n  /**\n   * same function as `Template.resourceCountIs`\n   *\n   * use this method like below:\n   *\n   * ```js\n   * template.resourceCountIs(AWS_EC2_SUBNET, 3)\n   * ```\n   * @param type\n   * @param count\n   */\n  resourceCountIs<T>(\n    type: (resource?: InputResourceWithoutType<T>) => InputResource<T>,\n    count: number\n  ): void {\n    this.template.resourceCountIs(type().Type, count);\n  }\n  /**\n   * same function as `Template.resourcePropertiesCountIs`\n   * @param r\n   * @param count\n   */\n  resourcePropertiesCountIs<T>(r: InputResource<T>, count: number): void {\n    this.template.resourcePropertiesCountIs(r.Type, r.Properties, count);\n  }\n  /**\n   * same function as `Template.hasResourceProperties`\n   * @param r\n   */\n  hasResourceProperties<T>(r: InputResource<T>): void {\n    this.template.hasResourceProperties(r.Type, r.Properties);\n  }\n  /**\n   * same function as `Template.hasResource`\n   * @param r\n   */\n  hasResource<T>(r: InputResource<T>): void {\n    this.template.hasResource(r.Type, r);\n  }\n  /**\n   * same function as `Template.findResources`\n   * @param r\n   * @returns\n   */\n  findResources<T>(r: InputResource<T>): ReturnValue<OutputResource<T>>[] {\n    const resources = this.template.findResources(r.Type, r) as {\n      [id in string]: OutputResource<T>;\n    };\n    return Object.entries(resources).map(([id, resource]) => {\n      return { id: id, def: resource };\n    });\n  }\n  /**\n   * same function as `Template.allResources`\n   * @param r\n   */\n  allResources<T>(r: InputResource<T>): void {\n    this.template.allResources(r.Type, r);\n  }\n  /**\n   * same function as `Template.allResourceProperties`\n   * @param r\n   */\n  allResourcesProperties<T>(r: InputResource<T>): void {\n    this.template.allResourcesProperties(r.Type, r.Properties);\n  }\n  /**\n   * same function as `Template.hasParameter`\n   * @param logicalId\n   * @param props\n   */\n  hasParameter(logicalId: string, props: InputParamter): void {\n    this.template.hasParameter(logicalId, props);\n  }\n  /**\n   * same function as `Template.findParameters`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findParameters(\n    logicalId: string,\n    props?: InputParamter\n  ): ReturnValue<OutputParameter>[] {\n    const parameters = this.template.findParameters(logicalId, props);\n    return Object.entries(parameters).map(([id, parameter]) => {\n      return { id: id, def: parameter as OutputParameter };\n    });\n  }\n\n  /**\n   * same function as `Template.hasOutput`\n   * @param logicalId\n   * @param props\n   */\n  hasOutput(logicalId: string, props: InputOutput): void {\n    this.template.hasOutput(logicalId, props);\n  }\n  /**\n   * same function as `Template.findOutputs`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findOutputs(\n    logicalId: string,\n    props?: InputOutput\n  ): ReturnValue<OutputOutput>[] {\n    const outputs = this.template.findOutputs(logicalId, props);\n    return Object.entries(outputs).map(([id, output]) => {\n      return { id: id, def: output as OutputOutput };\n    });\n  }\n  /**\n   * same function as `Template.hasMapping`\n   * @param logicalId\n   * @param props\n   */\n  hasMapping(logicalId: string, props: any): void {\n    this.template.hasMapping(logicalId, props);\n  }\n  /**\n   * same function as `Template.findMappings`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findMappings(logicalId: string, props?: any): ReturnValue<Mapping>[] {\n    const mappings = this.template.findMappings(logicalId, props);\n    return Object.entries(mappings).map(([id, mapping]) => {\n      return { id: id, def: mapping };\n    });\n  }\n  /**\n   * same function as `Template.hasCondition`\n   * @param logicalId\n   * @param props\n   */\n  hasCondition(logicalId: string, props: any): void {\n    this.template.hasCondition(logicalId, props);\n  }\n  /**\n   * same function as `Template.findConditions`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findConditions(logicalId: string, props?: any): ReturnValue<Condition>[] {\n    const conditions = this.template.findConditions(logicalId, props);\n    return Object.entries(conditions).map(([id, condition]) => {\n      return { id: id, def: condition };\n    });\n  }\n\n  /**\n   * return a single resource for specified type and definition.\n   *\n   * - if no resource matched with the specified type and definition, raise Error.\n   * - if multiple resources matched, raise Error\n   * @param args\n   * @returns\n   */\n  getResource<T>(\n    ...args: Parameters<typeof this.findResources<T>>\n  ): ReturnType<typeof this.findResources<T>> extends (infer U)[] ? U : never {\n    return this.get(\"resource\", args[0], this.findResources(args[0]));\n  }\n}\n\nexport interface JoinProps {\n  /**\n   * @default \"\"\n   */\n  delimiter?: string;\n  arrayWith: any[];\n}\n/**\n * provides some syntax sugars for `Match` class at `aws-cdk-lib/assertions`\n */\nexport class ExtraMatch extends Match {\n  /**\n   * same function as `Match.objectEquals({ Ref: logicalId })`\n   * @param logicalId\n   * @returns\n   */\n  static ref(logicalId: string): Matcher {\n    return Match.objectEquals({ Ref: logicalId });\n  }\n  /**\n   * same function as `Match.objectEquals({\"Fn::GetAtt\": [logicalId, attribute]})`\n   * @param logicalId\n   * @param attribute\n   * @returns\n   */\n  static getAtt(logicalId: string, attribute: string): Matcher {\n    return Match.objectEquals({ \"Fn::GetAtt\": [logicalId, attribute] });\n  }\n  /**\n   * same function as `Match.objectEquals({\"Fn::GetAtt\": [logicalId, \"Arn\"]})`\n   * @param logicalId\n   * @returns\n   */\n  static getAttArn(logicalId: string): Matcher {\n    return this.getAtt(logicalId, \"Arn\");\n  }\n\n  static arrayWith<T extends any[]>(pattern: AlsoMatcher<T>): TypedMatcher<T> {\n    return Match.arrayWith(pattern);\n  }\n  static arrayEquals<T extends any[]>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.arrayEquals(pattern);\n  }\n  static objectLike<T extends { [key: string]: any }>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.objectLike(pattern) as TypedMatcher<T>;\n  }\n  static objectEquals<T extends { [key: string]: any }>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.objectEquals(pattern);\n  }\n  static not<T>(pattern: AlsoMatcher<T>): TypedMatcher<T> {\n    return Match.not(pattern);\n  }\n  static exact<T>(pattern: AlsoMatcher<T>): TypedMatcher<T> {\n    return Match.exact(pattern);\n  }\n\n  /**\n   * same function as below:\n   * \n   * ```js\n   * Match.objectLike({\n   *  \"Fn::Join\": [props.delimiter ?? \"\", Match.arrayWith(props.arrayWith)],\n    });\n   * ```\n   * @param props \n   * @returns \n   */\n  static joinLike(props: JoinProps): Matcher {\n    return Match.objectLike({\n      \"Fn::Join\": [props.delimiter ?? \"\", Match.arrayWith(props.arrayWith)],\n    });\n  }\n\n  // /**\n  //  * returns Match instance that matches regional resource ARN like : `arn:aws:logs:ap-northeast-1:123456789012:log-group:/log-group-name:log-stream:log-stream-name`\n  //  * @param elems\n  //  * @returns\n  //  */\n  // static regionalArnLike(elems: AlsoMatcher<ArnElements>): Matcher {\n  //   return Match.objectEquals({\n  //     \"Fn::Join\": Match.arrayWith([\n  //       \"\",\n  //       Match.arrayWith([\n  //         \"arn:\",\n  //         elems.partition ?? { Ref: \"AWS::Partition\" },\n  //         Match.stringLikeRegexp(`:${elems.service ?? \"*\"}:`),\n  //         elems.region ?? { Ref: \"AWS::Region\" },\n  //         elems.account ?? { Ref: \"AWS::AccountId\" },\n  //         ...(elems.rest instanceof Matcher\n  //           ? [elems.rest]\n  //           : (elems.rest ?? [])),\n  //       ]),\n  //     ]),\n  //   });\n  // }\n\n  // /**\n  //  * returns Match instance that matches global resource ARN like : `arn:aws:iam::123456789012:role/role-name`\n  //  * @param elems\n  //  * @returns\n  //  */\n  // static globalArn(\n  //   elems: Omit<ArnElements, \"region\">,\n  //   delimiter: string = \"\"\n  // ): Matcher {\n  //   return Match.objectEquals({\n  //     \"Fn::Join\": Match.arrayEquals([\n  //       delimiter,\n  //       Match.arrayWith([\n  //         \"arn:\",\n  //         elems.partition ?? { Ref: \"AWS::Partition\" },\n  //         Match.stringLikeRegexp(`:${elems.service ?? \"*\"}::`),\n  //         elems.account ?? { Ref: \"AWS::AccountId\" },\n  //         ...(elems.rest instanceof Matcher\n  //           ? [elems.rest]\n  //           : (elems.rest ?? [])),\n  //       ]),\n  //     ]),\n  //   });\n  // }\n\n  static iamPolicyLike(doc: AlsoMatcher<IAMPolicyDocument>): Matcher {\n    return Match.objectLike(doc);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assertions.js","sourceRoot":"","sources":["assertions.ts"],"names":[],"mappings":"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","sourcesContent":["import { Template, Match, Matcher } from \"aws-cdk-lib/assertions\";\nimport {\n  Condition,\n  InputResource,\n  Mapping,\n  OutputResource,\n  InputParamter,\n  OutputParameter,\n  ReturnValue,\n  InputOutput,\n  OutputOutput,\n  InputResourceWithoutType,\n  IAMPolicyDocument,\n  AlsoMatcher,\n  TypedMatcher,\n} from \"./typed-resource\";\n\n/**\n * almost same class as `Template` class at \"aws-cdk-lib/assertions\", but you can use this with proper type definitions\n */\nexport class TypedTemplate {\n  template: Template;\n  private constructor(template: Template) {\n    this.template = template;\n  }\n\n  private get<T>(type: string, def: any, array: T[]): T {\n    if (array.length === 0) {\n      throw Error(`${type} not found with definition : ${JSON.stringify(def)}`);\n    }\n    if (array.length > 1) {\n      throw Error(\n        `multiple ${type} found with definition : ${JSON.stringify(def)}`\n      );\n    }\n    return array[0];\n  }\n\n  /**\n   * same function as `Template.fromStack` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromStack(\n    ...args: Parameters<typeof Template.fromStack>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromStack(...args));\n  }\n  /**\n   * same function as `Template.fromJSON` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromJSON(\n    ...args: Parameters<typeof Template.fromJSON>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromJSON(...args));\n  }\n  /**\n   * same function as `Template.fromString` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromString(\n    ...args: Parameters<typeof Template.fromString>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromString(...args));\n  }\n\n  /**\n   * same function as `Template.resourceCountIs`\n   *\n   * use this method like below:\n   *\n   * ```js\n   * template.resourceCountIs(AWS_EC2_SUBNET, 3)\n   * ```\n   * @param type\n   * @param count\n   */\n  resourceCountIs<T>(\n    type: (resource?: InputResourceWithoutType<T>) => InputResource<T>,\n    count: number\n  ): void {\n    this.template.resourceCountIs(type().Type, count);\n  }\n  /**\n   * same function as `Template.resourcePropertiesCountIs`\n   * @param r\n   * @param count\n   */\n  resourcePropertiesCountIs<T>(r: InputResource<T>, count: number): void {\n    this.template.resourcePropertiesCountIs(r.Type, r.Properties, count);\n  }\n  /**\n   * same function as `Template.hasResourceProperties`\n   * @param r\n   */\n  hasResourceProperties<T>(r: InputResource<T>): void {\n    this.template.hasResourceProperties(r.Type, r.Properties);\n  }\n  /**\n   * same function as `Template.hasResource`\n   * @param r\n   */\n  hasResource<T>(r: InputResource<T>): void {\n    this.template.hasResource(r.Type, r);\n  }\n  /**\n   * same function as `Template.findResources`\n   * @param r\n   * @returns\n   */\n  findResources<T>(r: InputResource<T>): ReturnValue<OutputResource<T>>[] {\n    const resources = this.template.findResources(r.Type, r) as {\n      [id in string]: OutputResource<T>;\n    };\n    return Object.entries(resources).map(([id, resource]) => {\n      return { id: id, def: resource };\n    });\n  }\n  /**\n   * same function as `Template.allResources`\n   * @param r\n   */\n  allResources<T>(r: InputResource<T>): void {\n    this.template.allResources(r.Type, r);\n  }\n  /**\n   * same function as `Template.allResourceProperties`\n   * @param r\n   */\n  allResourcesProperties<T>(r: InputResource<T>): void {\n    this.template.allResourcesProperties(r.Type, r.Properties);\n  }\n  /**\n   * same function as `Template.hasParameter`\n   * @param logicalId\n   * @param props\n   */\n  hasParameter(logicalId: string, props: InputParamter): void {\n    this.template.hasParameter(logicalId, props);\n  }\n  /**\n   * same function as `Template.findParameters`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findParameters(\n    logicalId: string,\n    props?: InputParamter\n  ): ReturnValue<OutputParameter>[] {\n    const parameters = this.template.findParameters(logicalId, props);\n    return Object.entries(parameters).map(([id, parameter]) => {\n      return { id: id, def: parameter as OutputParameter };\n    });\n  }\n\n  /**\n   * same function as `Template.hasOutput`\n   * @param logicalId\n   * @param props\n   */\n  hasOutput(logicalId: string, props: InputOutput): void {\n    this.template.hasOutput(logicalId, props);\n  }\n  /**\n   * same function as `Template.findOutputs`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findOutputs(\n    logicalId: string,\n    props?: InputOutput\n  ): ReturnValue<OutputOutput>[] {\n    const outputs = this.template.findOutputs(logicalId, props);\n    return Object.entries(outputs).map(([id, output]) => {\n      return { id: id, def: output as OutputOutput };\n    });\n  }\n  /**\n   * same function as `Template.hasMapping`\n   * @param logicalId\n   * @param props\n   */\n  hasMapping(logicalId: string, props: any): void {\n    this.template.hasMapping(logicalId, props);\n  }\n  /**\n   * same function as `Template.findMappings`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findMappings(logicalId: string, props?: any): ReturnValue<Mapping>[] {\n    const mappings = this.template.findMappings(logicalId, props);\n    return Object.entries(mappings).map(([id, mapping]) => {\n      return { id: id, def: mapping };\n    });\n  }\n  /**\n   * same function as `Template.hasCondition`\n   * @param logicalId\n   * @param props\n   */\n  hasCondition(logicalId: string, props: any): void {\n    this.template.hasCondition(logicalId, props);\n  }\n  /**\n   * same function as `Template.findConditions`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findConditions(logicalId: string, props?: any): ReturnValue<Condition>[] {\n    const conditions = this.template.findConditions(logicalId, props);\n    return Object.entries(conditions).map(([id, condition]) => {\n      return { id: id, def: condition };\n    });\n  }\n\n  /**\n   * return a single resource for specified type and definition.\n   *\n   * - if no resource matched with the specified type and definition, raise Error.\n   * - if multiple resources matched, raise Error\n   * @param args\n   * @returns\n   */\n  getResource<T>(\n    ...args: Parameters<typeof this.findResources<T>>\n  ): ReturnType<typeof this.findResources<T>> extends (infer U)[] ? U : never {\n    return this.get(\"resource\", args[0], this.findResources(args[0]));\n  }\n}\n\nexport interface JoinProps {\n  /**\n   * @default \"\"\n   */\n  delimiter?: string;\n  arrayWith: any[];\n}\n/**\n * provides some syntax sugars for `Match` class at `aws-cdk-lib/assertions`\n */\nexport class ExtraMatch {\n  /**\n   * same function as `Match.objectEquals({ Ref: logicalId })`\n   * @param logicalId\n   * @returns\n   */\n  static ref(logicalId: string): Matcher {\n    return Match.objectEquals({ Ref: logicalId });\n  }\n  /**\n   * same function as `Match.objectEquals({\"Fn::GetAtt\": [logicalId, attribute]})`\n   * @param logicalId\n   * @param attribute\n   * @returns\n   */\n  static getAtt(logicalId: string, attribute: string): Matcher {\n    return Match.objectEquals({ \"Fn::GetAtt\": [logicalId, attribute] });\n  }\n  /**\n   * same function as `Match.objectEquals({\"Fn::GetAtt\": [logicalId, \"Arn\"]})`\n   * @param logicalId\n   * @returns\n   */\n  static getAttArn(logicalId: string): Matcher {\n    return this.getAtt(logicalId, \"Arn\");\n  }\n  /**\n   * same function as below:\n   * \n   * ```js\n   * Match.objectLike({\n   *  \"Fn::Join\": [props.delimiter ?? \"\", Match.arrayWith(props.arrayWith)],\n    });\n   * ```\n   * @param props \n   * @returns \n   */\n  static joinLike(props: JoinProps): Matcher {\n    return Match.objectLike({\n      \"Fn::Join\": [props.delimiter ?? \"\", Match.arrayWith(props.arrayWith)],\n    });\n  }\n\n  /**\n   You can define Matcher for IAM Policy Document with type hints.\n   ```js\n    template.hasResource(\n      AWS_IAM_ROLE({\n        Properties: {\n          AssumeRolePolicyDocument: ExtraMatch.iamPolicyLike({\n            Statement: [\n              {\n                Principal: { Service: \"ec2.amazonaws.com\" },\n              },\n            ],\n          }),\n        },\n      })\n    );\n   ```\n   * @param doc \n   * @returns \n   */\n  static iamPolicyLike(doc: AlsoMatcher<IAMPolicyDocument>): Matcher {\n    return Match.objectLike(doc);\n  }\n  /**\n   Same method as `Match.arrayWith` but provides type hints and validate type match \n   ```js\n    // this is a right code\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayWith<Tag[]>([\n            {\n              Key: \"key2\",\n              Value: \"val2\",\n            },\n          ]),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayWith<string[]>([\n            \"hoge\", \"fuga\"\n          ]),\n        },\n      })\n    );\n   ```\n   * @param pattern \n   * @returns \n   */\n  static arrayWith<T extends any[]>(pattern: AlsoMatcher<T>): TypedMatcher<T> {\n    return Match.arrayWith(pattern) as unknown as TypedMatcher<T>;\n  }\n  /**\n   * Same method as `Match.arrayEquals` but provides type hints and validate type match \n   ```js\n    // this is a right code\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayEquals<Tag[]>([\n            {\n              Key: \"key1\",\n              Value: \"val1\",\n            },\n            {\n              Key: \"key2\",\n              Value: \"val2\",\n            },\n          ]),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayEquals<Tag[]>([\n            {\n              Key: \"key1\",\n              Value: \"val1\",\n            },\n            {\n              Key: 100,\n              Value: 200,\n            },\n          ]),\n        },\n      })\n    );\n   ```\n   * @param pattern \n   * @returns \n   */\n  static arrayEquals<T extends any[]>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.arrayEquals(pattern);\n  }\n  /**\n   * Same method as `Match.objectLike` but provides type hints and validate type match \n   ```js\n   // this is a right code\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          BlockDeviceMappings: [\n            {\n              DeviceName: \"test\",\n              Ebs: ExtraMatch.objectLike<Ebs>({\n                VolumeSize: 10,\n              }),\n            },\n          ],\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          BlockDeviceMappings: [\n            {\n              DeviceName: \"test\",\n              Ebs: ExtraMatch.objectLike<Ebs>({\n                VolumeSize: \"10\",\n              }),\n            },\n          ],\n        },\n      })\n    );\n   * @param pattern \n   * @returns \n   */\n  static objectLike<T extends { [key: string]: any }>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.objectLike(pattern);\n  }\n  /**\n   * Same method as `Match.objectEquals` but provides type hints and validate type match \n   ```js\n   // this is a right code\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          // You can nest TypedMatcher(use TypedMatcher inside TypedMatcher)\n          Tags: ExtraMatch.arrayWith<Tag[]>([\n            ExtraMatch.objectEquals<Tag>({\n              Key: \"key1\",\n              Value: \"val1\",\n            }),\n          ]),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayWith<Tag[]>([\n            ExtraMatch.objectEquals<Tag>({\n              Key: \"key1\",\n              Value: 100,\n            }),\n          ]),\n        },\n      })\n    );\n   * @param pattern \n   * @returns \n   */\n  static objectEquals<T extends { [key: string]: any }>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.objectEquals(pattern);\n  }\n  /**\n   * Same method as `Match.not` but provides type hints and validate type match \n   ```js\n    // this is a right code\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          ImageId: ExtraMatch.not(\"ami-12345\"),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          ImageId: ExtraMatch.not(100),\n        },\n      })\n    );\n   ```\n   * Same method as `Match.not` but provides type hints and validate type match \n   * @param pattern \n   * @returns \n   */\n  // TODO: why this expression `T extends never ? never : T` is required but this is required\n  static not<T>(pattern: AlsoMatcher<T extends never ? never : T>): TypedMatcher<T> {\n    return Match.not(pattern);\n  }\n  /**\n   * Same method as `Match.exact` but provides type hints and validate type match \n   ```js\n    // this is a right code\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          InstanceType: ExtraMatch.exact(\"t2.micro\"),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          InstanceType: ExtraMatch.exact(false),\n        },\n      })\n    );\n   ```\n   * @param pattern \n   * @returns \n   */\n  static exact<T>(pattern: AlsoMatcher<T extends never ? never : T>): TypedMatcher<T> {\n    return Match.exact(pattern);\n  }\n}\n"]}

package/lib/typed-resource.d.ts

@@ -1,6 +1,6 @@
 import { Matcher } from "aws-cdk-lib/assertions";
 type Primitives = string | number | boolean | undefined | null | symbol | bigint | string[] | number[] | boolean[] | bigint[];
-export type TypedMatcher<T> = Matcher;
+export type TypedMatcher<T> = Matcher | T;
 /**
  * make properties of `T` asignable Matcher recirsively and other arbitrary json objects for primitive type fields
  */

package/lib/typed-resource.js

@@ -30,4 +30,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //    */
 //   rest?: string[];
 // }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/cfn-resource-types/aws-accessanalyzer-analyzer.d.ts

@@ -22,7 +22,7 @@ export interface _AWS_ACCESSANALYZER_ANALYZER {
      */
     Tags?: Tag[];
     /**
-     * The type of the analyzer, must be one of ACCOUNT, ORGANIZATION, ACCOUNT_UNUSED_ACCESS or ORGANIZATION_UNUSED_ACCESS
+     * The type of the analyzer, must be one of ACCOUNT, ORGANIZATION, ACCOUNT_INTERNAL_ACCESS, ORGANIZATION_INTERNAL_ACCESS, ACCOUNT_UNUSED_ACCESS and ORGANIZATION_UNUSED_ACCESS
      */
     Type: string;
     /**
@@ -30,6 +30,7 @@ export interface _AWS_ACCESSANALYZER_ANALYZER {
      */
     AnalyzerConfiguration?: {
         UnusedAccessConfiguration?: UnusedAccessConfiguration;
+        InternalAccessConfiguration?: InternalAccessConfiguration;
     };
 }
 /**
@@ -100,3 +101,34 @@ export interface AnalysisRuleCriteria {
      */
     ResourceTags?: Tags[];
 }
+/**
+ * Specifies the configuration of an internal access analyzer for an AWS organization or account. This configuration determines how the analyzer evaluates internal access within your AWS environment.
+ */
+export interface InternalAccessConfiguration {
+    /**
+     * Contains information about analysis rules for the internal access analyzer. Analysis rules determine which entities will generate findings based on the criteria you define when you create the rule.
+     */
+    InternalAccessAnalysisRule?: {
+        /**
+         * A list of rules for the internal access analyzer containing criteria to include in analysis. Only resources that meet the rule criteria will generate findings.
+         */
+        Inclusions?: InternalAccessAnalysisRuleCriteria[];
+    };
+}
+/**
+ * The criteria for an analysis rule for an internal access analyzer.
+ */
+export interface InternalAccessAnalysisRuleCriteria {
+    /**
+     * A list of AWS account IDs to apply to the internal access analysis rule criteria. Account IDs can only be applied to the analysis rule criteria for organization-level analyzers and cannot include the organization owner account.
+     */
+    AccountIds?: string[];
+    /**
+     * A list of resource ARNs to apply to the internal access analysis rule criteria. The analyzer will only generate findings for resources that match these ARNs.
+     */
+    ResourceArns?: string[];
+    /**
+     * A list of resource types to apply to the internal access analysis rule criteria. The analyzer will only generate findings for resources of these types.
+     */
+    ResourceTypes?: string[];
+}

package/lib/types/cfn-resource-types/aws-accessanalyzer-analyzer.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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