diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..6fc62d3 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,60 @@ +## Proposed changes + + + +## Issues for these changes + + + +## Types of changes + + + +- [ ] Bugfix (non-breaking change which fixes an issue) +- [ ] New feature (non-breaking change which adds functionality) +- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected) +- [ ] Refactor (changes to code, which do not change application behavior) + +## Checklist + + + +- [ ] I have filled out this PR template +- [ ] I have read the [CONTRIBUTING](../CONTRIBUTING.md) doc +- [ ] I have added automated tests that prove my fix is effective or that my feature works +- [ ] I have added necessary documentation (`README.md`, `CHANGELOG.md`, etc. - if appropriate) + +## Dependencies and Blockers + + + +## Relevant Links + + + +## Further comments + + diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..de0404a --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,25 @@ +name: build +on: + push: + branches: + - main + pull_request: + branches: + - main +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: run build + run: make build + - name: run test for report + run: make report + env: + GOPATH: /home/runner/work/cloudig/go + - name: Publish Unit Test Results + uses: EnricoMi/publish-unit-test-result-action@v1.7 + if: always() + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + files: reports/*.xml diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..03e5d4c --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,29 @@ +name: release + +on: + push: + tags: + - "*" + +permissions: + contents: write + +jobs: + goreleaser: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v2 + with: + fetch-depth: 0 + - name: Set up Go + uses: actions/setup-go@v2 + with: + go-version: 1.16 + - name: Run GoReleaser + uses: goreleaser/goreleaser-action@v2 + with: + version: latest + args: release --rm-dist + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/sourcehawk-scan.yml b/.github/workflows/sourcehawk-scan.yml new file mode 100644 index 0000000..72a2af8 --- /dev/null +++ b/.github/workflows/sourcehawk-scan.yml @@ -0,0 +1,20 @@ +name: Sourcehawk Scan +on: + push: + branches: + - main + - master + pull_request: + branches: + - main + - master +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Sourcehawk Scan + uses: optum/sourcehawk-scan-github-action@main + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..21948b4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +reports/* +report.md +cloudig +cloudig* +!pkg/** +.DS_STORE +.vscode +.idea/ +cover.out +dist/ \ No newline at end of file diff --git a/.goreleaser.yml b/.goreleaser.yml new file mode 100644 index 0000000..abcb798 --- /dev/null +++ b/.goreleaser.yml @@ -0,0 +1,30 @@ +# This is an example .goreleaser.yml file with some sane defaults. +# Make sure to check the documentation at http://goreleaser.com +before: + hooks: + # You may remove this if you don't use go modules. + - go mod tidy +builds: + - env: + - CGO_ENABLED=0 + goos: + - linux + - windows + - darwin +archives: + - replacements: + darwin: Darwin + linux: Linux + windows: Windows + 386: i386 + amd64: x86_64 +checksum: + name_template: "checksums.txt" +snapshot: + name_template: "{{ .Tag }}-next" +changelog: + sort: asc + filters: + exclude: + - "^docs:" + - "^test:" diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..765a405 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,3 @@ +## v0.1.0 + +Initial release diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..52c7f95 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,75 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +nationality, personal appearance, race, religion, or sexual identity and +orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or +advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project email +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at [opensource@optum.com][email]. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ +[email]: mailto:opensource@optum.com \ No newline at end of file diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..96118fa --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,54 @@ +# Contribution Guidelines + +Please note that this project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms. Please also review our [Contributor License Agreement ("CLA")](INDIVIDUAL_CONTRIBUTOR_LICENSE.md) prior to submitting changes to the project. You will need to attest to this agreement following the instructions in the [Paperwork for Pull Requests](#paperwork-for-pull-requests) section below. + +--- + +# How to Contribute + +Now that we have the disclaimer out of the way, let's get into how you can be a part of our project. There are many ways to contribute. + +## Issues + +We track our work using Issues in GitHub. Feel free to open up your own issue to point out areas for improvement or to suggest your own new experiment. If you are comfortable signing the waiver linked above and contributing code or documentation, grab your own issue and start working. + +## Coding Standards + +We have some general guidelines towards contributing to this project. + +### Languages + +_Go_ + +## Pull Requests + +If you've gotten as far as reading this section, then thank you for your suggestions. + +### Paperwork for Pull Requests + +- Please read this guide and make sure you agree with our [Contributor License Agreement ("CLA")](INDIVIDUAL_CONTRIBUTOR_LICENSE.md). +- Make sure git knows your name and email address: + ``` + $ git config user.name "J. Random User" + $ git config user.email "j.random.user@example.com" + ``` + > The name and email address must be valid as we cannot accept anonymous contributions. +- Write good commit messages. + > Concise commit messages that describe your changes help us better understand your contributions. +- The first time you open a pull request in this repository, you will see a comment on your PR with a link that will allow you to sign our Contributor License Agreement (CLA) if necessary. + > The link will take you to a page that allows you to view our CLA. You will need to click the `Sign in with GitHub to agree button` and authorize the cla-assistant application to access the email addresses associated with your GitHub account. Agreeing to the CLA is also considered to be an attestation that you either wrote or have the rights to contribute the code. All committers to the PR branch will be required to sign the CLA, but you will only need to sign once. This CLA applies to all repositories in the Optum org. + +## General Guidelines + +Ensure your pull request (PR) adheres to the following guidelines: + +- Try to make the name concise and descriptive. +- Give a good description of the change being made. Since this is very subjective, see the [Updating Your Pull Request (PR)](#updating-your-pull-request-pr) section below for further details. +- Every pull request should be associated with one or more issues. If no issue exists yet, please create your own. +- Make sure that all applicable issues are mentioned somewhere in the PR description. This can be done by typing # to bring up a list of issues. + +### Updating Your Pull Request (PR) + +A lot of times, making a PR adhere to the standards above can be difficult. If the maintainers notice anything that we'd like changed, we'll ask you to edit your PR before we merge it. This applies to both the content documented in the PR and the changed contained within the branch being merged. There's no need to open a new PR. Just edit the existing one. + +[email]: mailto:opensource@optum.com diff --git a/INDIVIDUAL_CONTRIBUTOR_LICENSE.md b/INDIVIDUAL_CONTRIBUTOR_LICENSE.md new file mode 100644 index 0000000..7cfe7b8 --- /dev/null +++ b/INDIVIDUAL_CONTRIBUTOR_LICENSE.md @@ -0,0 +1,31 @@ +# Individual Contributor License Agreement ("Agreement") V2.0 + +Thank you for your interest in this Optum project (the "PROJECT"). In order to clarify the intellectual property license granted with Contributions from any person or entity, the PROJECT must have a Contributor License Agreement ("CLA") on file that has been signed by each Contributor, indicating agreement to the license terms below. This license is for your protection as a Contributor as well as the protection of the PROJECT and its users; it does not change your rights to use your own Contributions for any other purpose. + +You accept and agree to the following terms and conditions for Your present and future Contributions submitted to the PROJECT. In return, the PROJECT shall not use Your Contributions in a way that is inconsistent with stated project goals in effect at the time of the Contribution. Except for the license granted herein to the PROJECT and recipients of software distributed by the PROJECT, You reserve all right, title, and interest in and to Your Contributions. + +1. Definitions. + +"You" (or "Your") shall mean the copyright owner or legal entity authorized by the copyright owner that is making this Agreement with the PROJECT. For legal entities, the entity making a Contribution and all other entities that control, are controlled by, or are under common control with that entity are considered to be a single Contributor. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"Contribution" shall mean any original work of authorship, including any modifications or additions to an existing work, that is intentionally submitted by You to the PROJECT for inclusion in, or documentation of, any of the products owned or managed by the PROJECT (the "Work"). For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the PROJECT or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the PROJECT for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by You as "Not a Contribution." + +2. Grant of Copyright License. + +Subject to the terms and conditions of this Agreement, You hereby grant to the PROJECT and to recipients of software distributed by the PROJECT a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Your Contributions and such derivative works. + +3. Grant of Patent License. + +Subject to the terms and conditions of this Agreement, You hereby grant to the PROJECT and to recipients of software distributed by the PROJECT a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable(except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by You that are necessarily infringed by Your Contribution(s) alone or by combination of Your Contribution(s) with the Work to which such Contribution(s) was submitted. If any entity institutes patent litigation against You or any other entity (including a cross-claim or counterclaim in a lawsuit) alleging that your Contribution, or the Work to which you have contributed, constitutes direct or contributory patent infringement, then any patent licenses granted to that entity under this Agreement for that Contribution or Work shall terminate as of the date such litigation is filed. + +4. Representations. + + (a) You represent that you are legally entitled to grant the above license. If your employer(s) has rights to intellectual property that you create that includes your Contributions, you represent that you have received permission to make Contributions on behalf of that employer, that your employer has waived such rights for your Contributions to the PROJECT, or that your employer has executed a separate Corporate CLA with the PROJECT. + + (b) You represent that each of Your Contributions is Your original creation (see section 6 for submissions on behalf of others). You represent that Your Contribution submissions include complete details of any third-party license or other restriction (including, but not limited to, related patents and trademarks) of which you are personally aware and which are associated with any part of Your Contributions. + +5. You are not expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all. Unless required by applicable law or agreed to in writing, You provide Your Contributions on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. + +6. Should You wish to submit work that is not Your original creation, You may submit it to the PROJECT separately from any Contribution, identifying the complete details of its source and of any license or other restriction (including, but not limited to, related patents, trademarks, and license agreements) of which you are personally aware, and conspicuously marking the work as "Submitted on behalf of a third-party: [named here]". + +7. You agree to notify the PROJECT of any facts or circumstances of which you become aware that would make these representations inaccurate in any respect. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..3b0a84e --- /dev/null +++ b/Makefile @@ -0,0 +1,44 @@ +VERSION=$(shell cat VERSION) +.PHONY: test + +all: test build + +build: + go build -ldflags="-X github.com/Optum/cloudig/cmd.version=${VERSION}" -o cloudig + +mocks: + mockgen -destination=pkg/mocks/mock_ec2.go -package=mocks github.com/aws/aws-sdk-go/service/ec2/ec2iface EC2API + mockgen -destination=pkg/mocks/mock_inspector.go -package=mocks github.com/aws/aws-sdk-go/service/inspector/inspectoriface InspectorAPI + mockgen -destination=pkg/mocks/mock_trustedadvisor.go -package=mocks github.com/aws/aws-sdk-go/service/support/supportiface SupportAPI + mockgen -destination=pkg/mocks/mock_awsconfig.go -package=mocks github.com/aws/aws-sdk-go/service/configservice/configserviceiface ConfigServiceAPI + mockgen -destination=pkg/mocks/mock_sts.go -package=mocks github.com/aws/aws-sdk-go/service/sts/stsiface STSAPI + mockgen -destination=pkg/mocks/mock_health.go -package=mocks github.com/aws/aws-sdk-go/service/health/healthiface HealthAPI + mockgen -destination=pkg/mocks/mock_aws.go -package=mocks github.com/Optum/cloudig/pkg/aws APIs + mockgen -destination=pkg/mocks/mock_ecr.go -package=mocks github.com/aws/aws-sdk-go/service/ecr/ecriface ECRAPI + mockgen -destination=pkg/mocks/mock_cloudtrail.go -package=mocks github.com/aws/aws-sdk-go/service/cloudtrail/cloudtrailiface CloudTrailAPI + mockgen -destination=pkg/mocks/mock_athena.go -package=mocks github.com/aws/aws-sdk-go/service/athena/athenaiface AthenaAPI + mockgen -destination=pkg/mocks/mock_iam.go -package=mocks github.com/aws/aws-sdk-go/service/iam/iamiface IAMAPI + +test: + echo "Running tests" + go clean -testcache + go test -v -cover ./pkg/aws + go test -v -cover ./pkg/cloudig + +report: + go clean -testcache + go get -u github.com/jstemmer/go-junit-report + mkdir -p reports + go test -v -cover ./pkg/aws | tee /dev/tty | ${GOPATH}/bin/go-junit-report > reports/test_awspackage.xml + go test -v -cover ./pkg/cloudig | tee /dev/tty | ${GOPATH}/bin/go-junit-report > reports/test_cloudigpackage.xml + go mod tidy + + +compile: + echo "Compiling for Linux, Windows, and Mac" + env GOOS=linux GOARCH=amd64 go build -ldflags="-X github.com/Optum/cloudig/cmd.version=${VERSION}" -o cloudig_linux_amd64_${VERSION} main.go + env GOOS=windows GOARCH=amd64 go build -ldflags="-X github.com/Optum/cloudig/cmd.version=${VERSION}" -o cloudig_windows_amd64_${VERSION} main.go + env GOOS=darwin GOARCH=amd64 go build -ldflags="-X github.com/Optum/cloudig/cmd.version=${VERSION}" -o cloudig_darwin_amd64_${VERSION} main.go + +clean: + rm cloudig* diff --git a/NOTICE.txt b/NOTICE.txt new file mode 100644 index 0000000..d34dda8 --- /dev/null +++ b/NOTICE.txt @@ -0,0 +1,11 @@ +cloudig +Copyright 2021 Optum + +Project Description: +==================== +Get governance reports generated for Cloud from native services in a clear and readable digest + +Author(s): +Bradley Fisher (@bjfish25) +Rajendra Raghavendra (@rajholla) +Jack Shubatt (@shubydo) diff --git a/README.md b/README.md new file mode 100644 index 0000000..4dda92a --- /dev/null +++ b/README.md @@ -0,0 +1,318 @@ +[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/optum/cloudig/graphs/commit-activity) +![build](https://github.com/optum/cloudig/workflows/build/badge.svg?branch=main) +[![Github all releases](https://img.shields.io/github/downloads/optum/cloudig/total.svg)](https://GitHub.com/optum/cloudig/releases/) + +[comment]: <> (CLA assistant) + +[![made-with-Go](https://img.shields.io/badge/Made%20with-Go-1f425f.svg)](http://golang.org) + +![cloudig](./logo.png) + +cloudig, or Cloudigest, is a simple CLI tool for creating reports from various cloud sources with user-provided comments. It is written in Go and currently uses AWS APIs to generate reports based on five pillars — operational excellence, security, reliability, performance efficiency, and cost optimization. CLI allows users to provide comments for documenting exceptions and work in progress. This report can be useful in various use cases such as a quality gate step in IaC CI/CD pipeline, daily monitoring for operations to keep account status of multiple accounts in green status, single source for enterprise security/compliance teams to endorse the accounts, etc. + +The currently supported cloud sources are: + +- [AWS IAM Reflect](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html): This custom source uses [CloudTrail](https://aws.amazon.com/cloudtrail/) for event history of AWS IAM role activity and IAM to compare the actual permissions. + +- [AWS Trusted Advisor](https://aws.amazon.com/premiumsupport/trustedadvisor/): Provides real time guidance to help provision resources following AWS best practices. 100+ checks on cost optimization, security, fault tolerance, performance, and service limits + +- [AWS Config](https://aws.amazon.com/config/): Continuously monitors and records our AWS resource configurations and allows us to automate the evaluation of recorded configurations against desired configurations. This [module](https://github.com/Optum/aws_config) can help enable AWS Config with the desired configuration baseline. + +- [AWS Inspector](https://aws.amazon.com/inspector/): Automatically assesses applications running in EC2 instances for exposure, vulnerabilities, and deviations from best practices. After performing an assessment, Amazon Inspector produces a detailed list of security findings prioritized by level of severity. + +- [AWS ECR Scan](https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html) : Provides image scanning to identify software vulnerabilities in container images. + +- [AWS Health Notifications](https://aws.amazon.com/premiumsupport/technology/personal-health-dashboard/): Provides relevant and timely information to help manage events in progress, and provides proactive notification to help you plan for scheduled activities. + +### Example output: + +``` +[ℹ] reading comments from file comments.yaml +[ℹ] working on reflect report for account: 111111111111 +[ℹ] getting the s3 prefix associated with the CloudTrail +[ℹ] constructing the Athena table metadata form the s3 prefix +[ℹ] finding the existing Athena table from the constructed metadata +[ℹ] found the existing Athena table: default.reflect_cloudtrail_gxev4 +[ℹ] populating findings for roles +[✔] successfully populated the findings for roles +[ℹ] finding the actual permission for the roles +[✔] reflecting on account 111111111111 took 23.793137533s +{ + "findings": [ + { + "accountId": "111111111111", + "IAMIdentity": "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + "accessDetails": [ + { + "IAMAction": "kms.amazonaws.com/Decrypt", + "UsageCount": 3 + } + ], + "permissionSet": [ + "kms:ListKeys", + "kms:ListGrants", + "kms:GenerateDataKeyWithoutPlaintext", + "kms:GenerateDataKey", + "kms:Encrypt", + "kms:DescribeKey", + "kms:Decrypt", + "events:PutEvents" + ], + "comments": "**WORK_IN_PROGRESS:** Lot of unnecessary permissions" + } + ], + "reportTime": "21 Dec 20 10:53 CST" +} +``` + +### Installation + +`cloudig` can be installed two ways: + +1. Downloading latest release binary: + +```bash +# Darwin_arm64 +# 0.1.0 + + curl -O https://github.com/Optum/cloudig/releases/download/v/cloudig__.tar.gz \ + && tar -xf cloudig__.tar.gz \ + && chmod +x cloudig \ + && mv cloudig /usr/local/bin \ + && cloudig --help +``` + +2. Cloning repo and running `make build` **NOTE: must have Go installed** + +```bash +git clone https://github.com/Optum/cloudig.git + +cd cloudig + +make build + +./cloudig --help +``` + +#### CLI Verbs + +`get` - Get reports. Get ready-made reports directly from sources like Trusted Advisor, ECR scan, etc. + +`reflect` - Reflect on resources. Custom reports based on past usage and current configurations. Ex: Reflect on IAM role usage. + +#### Global Flags + +`--help`,`-h` : Generate help documentation + +`--version` : Prints version of the CLI + +`--rolearn`: (Optional) Takes the comma separated list of role ARN's. Provided role must have minimum permission needed to pull findings from AWS sources. Also, your parent account must have trust relationship so it can assume the role. When no role is provided, findings are only from the account associated with provided credentials + +`--cfile`, `-c`: (Optional) YAML file to provide user comments for each finding. When this file is not provided, each finding is treated as a new finding + +`--region`, `-r`: (Optional) AWS region to get results from. Default is us-east-1 + +`--output`, `-o`: (Optional) Output of the report. Options: json, table, and mdtable. Default is JSON + +`--verbose`, `-v`: (Optional) set log level, use 0 to silence, 1 for critical, 2 for warning, 3 for informational, 4 for debugging and 5 for debugging with AWS debug logging (default 3) + +#### IAM Reflect source specific flags + +`--identity`, `-i`: (Optional) One or more IAM Identities (users, groups, and roles) ARNs separated by a comma [,]. Only role ARN is supported today + +`--identity-tags`, `-t`: (Optional) Set of tags in form [key:value] separated by [,] to find the targeted IAM Identities. Only role ARNs is supported today. Ignored when --identity is provided + +`--usage`, `-u` : (Optional) Reflect Identity usage data (default true, if --errors/-e is not explicitly provided) + +`--errors`, `-e` : (Optional) Reflect Identity error data (default true, if --usage/-u is not explicitly provided) + +`--caller-identity` : (Optional) Include caller identity with the report(default false) + +`--absolute-time` : (Optional) Specify both the start and end times for the time filter in the form 'startTime-endTime' 'mm/dd/yyyy-mm/dd/yyy' ex: '10/25/2020-10/31/2020' + +`--relative-time` : (Optional) Specify a time filter relative to the current time in days. Default 1 day. Ignored when absolute-time is provided + +#### Health source specific flags + +`--details`, `-d`: (Optional) Health event descriptions are often very long, thus, by default, it is shortened to three sentences. If this flag is added, then the entire description is printed out. + +`--pastdays`: (Optional) Number of past days to get results from. Default is all health events that are open / upcoming. + +#### Source specific examples: + +- [IAM Reflect](doc/reflectiam.md) +- [TrustedAdvisor](doc/trustedadvisor.md) +- [AWS Config](doc/awsconfig.md) +- [Inspector](doc/inspector.md) +- [ECR Scan](doc/ecrscan.md) +- [AWS Health](doc/health.md) + +#### Disclaimer + +Even though the goal of "IAM reflect" is following the "Principle of least privilege" by keeping "Configured Permissions" equal to "Actual used Permissions", it is not always possible. This is mainly because some of the API actions for various AWS services are not tracked in CloudTrail, such as S3 & CloudWatch data events. +Also, in some cases, API actions are named slightly differently. Don't let the perfect be the enemy of the good. Use this wisely! +More info [1](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-list) & [2](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-and-data-events-with-cloudtrail.html#logging-data-events) + +Reflect uses CloudTrail event data stored in S3 and currently assumes partitions in the form `${Trail log location}/${region}/${year}/${month}/${day}`. +It returns zero results if it doesn't find the necessary partitions. We should be able to support different partition schemes in future releases. + +#### Comment file(cfile): + +Comment file provides a way to pass in user comments to findings from various sources. By default, CLI looks for the file name 'comments.yaml' to parse the comments. +User can also provide a different location by using flag `--cfile` or `-c` + +Below is the sample file: + +```yaml +- accountid: "111111111111" + ta-findings: + - SECURITY-IAM_Use: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM" + config-findings: + - IAM_POLICY_BLACKLISTED_CHECK: "**EXCEPTION:** Removed the AdministratorAccess policy since the default AWS_*_Admins uses the policy. Future enhancement would be to create a Custom Rule that no other Role can use the AdministratorAccess policy besides the AWS_*_Admins" + inspector-findings: + - CIS_Operating_System_Security_Configuration_Benchmarks-1.0: "**EXCEPTION:*** Description here" + health-findings: + - AWS_RDS_SECURITY_NOTIFICATION: "**EXCEPTION:** Description here" +``` + +#### IAM permission requirements + +Sample Policy needed to run cloudig and ability to use assume role to run report across multiple accounts: + +```hcl +data "aws_iam_policy_document" "cloudig_policy" { + statement { + effect = "Allow" + + actions = [ + "support:*", + "config:GetComplianceSummaryByConfigRule", + "config:GetComplianceDetailsByConfigRule", + "config:DescribeComplianceByConfigRule", + "config:DescribeComplianceByResource", + "config:DescribeConfigRules", + "health:DescribeEvents", + "health:DescribeEventDetails", + "health:DescribeAffectedEntities", + "inspector:GetAssessmentReport", + "inspector:ListAssessmentRuns", + "inspector:ListAssessmentTemplates", + "inspector:DescribeAssessmentTemplates", + "inspector:DescribeAssessmentTargets", + "inspector:DescribeResourceGroups", + "ec2:DescribeInstances", + "ec2:DescribeImages", + "ecr:DescribeRepositories", + "ecr:ListImages", + "ecr:DescribeImages", + "ecr:DescribeImageScanFindings", + "iam:ListRolePolicies", + "iam:ListRoles", + "iam:ListRoleTags", + "iam:GetRolePolicy", + "iam:ListAttachedRolePolicies", + "iam:GetPolicyVersion", + "sts:GetCallerIdentity", + "s3:ListBucket", + "s3:GetObject", + "s3:PutObject", + "s3:GetBucketLocation", + "cloudtrail:DescribeTrails", + "athena:GetQueryExecution", + "athena:StartQueryExecution", + "athena:ListTableMetadata", + "athena:ListDatabases", + "athena:GetTableMetadata", + "athena:ListDataCatalogs", + "athena:GetQueryResults", + "glue:GetTables", + "glue:GetDatabase", + "glue:CreateTable", + "glue:GetDatabases", + "glue:GetTable", + ] + resources = ["*"] + } +} + +data "aws_iam_policy_document" "cloudig_assume_role" { + statement { + effect = "Allow" + + actions = [ + "sts:AssumeRole", + ] + + principals { + type = "AWS" + identifiers = ["arn:aws:iam::111111111111:role/AWS_111111111111_Read"] + } + } +} + +resource "aws_iam_role" "cloudig_role" { + name = "cloudig" + assume_role_policy = data.aws_iam_policy_document.cloudig_assume_role.json +} + +resource "aws_iam_role_policy" "cloudig_policy" { + name = "cloudig" + role = aws_iam_role.cloudig_role.id + policy = data.aws_iam_policy_document.cloudig_policy.json +} +``` + +**Note**: Support doesn't let you allow or deny access to individual actions. Therefore, the Action element of a policy is always set to support:_. +Similarly, Support & Inspector don't provide resource-level access, so the Resource element is always set to _. Need access to EC2 for getting AMI information + +### Developer Notes + +#### Build + +cloudig uses the Go Modules support built into Go 1.11. Make sure installed go version is at least 1.11 + +`go build -o cloudig` OR `make build` + +Build for different Target OS and Platform: + +`env GOOS= GOARCH= go build -o cloudig` + +OR + +`make compile` + +- This will compile the 64-bit binaries for Linux, Windows, and Mac + +#### Testing + +Running the tests: `make test` + +Validating the test coverage : + +```bash +go test -v -coverprofile cover.out github.com/Optum/cloudig/pkg/cloudig + +go tool cover -html=cover.out // opens a html output in default browser + +``` + +**Testing methodology**: + +cloudig tests are written using the [GoMock](https://github.com/golang/mock) mocking framework and table-driven tests. + +A few of the reasons we chose to use GoMock are: + +1. Allows us to write tests for functions that make API calls without actually making the call. + +2. Integrates well with the standard library testing package: `testing`. + +Examples of these tests can be found under the `pkg/aws` and `pkg/cloudig` folders + +The mocks that were generated can be found under the `pkg/mocks` folder and the commands used to generate them can be found [here](/pkg/mocks/README.md) + +#### Logging + +This project uses a very simple but effective [logger library](https://github.com/kris-nova/logger) that allows us to set a different logging level with the flag `--verbose` or `-v`. Different levels are 1 for critical, 2 for warning, 3 for informational, 4 for debugging, and 5 for debugging with AWS debug logging with the default being 3 (informational). + +- Files supporting commands in `package cmd` and controller logic in `package cloudig` are instrumented to log at a different level. +- AWS interactions in `package aws` are purposefully kept out of adding more logging as we can always use `-v5` to enable AWS SDK debug logging. All methods in AWS client is expected to promptly propagate the error back to the caller to avoid duplicate logging. diff --git a/VERSION b/VERSION new file mode 100644 index 0000000..b82608c --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +v0.1.0 diff --git a/attribution.txt b/attribution.txt new file mode 100644 index 0000000..2d719c4 --- /dev/null +++ b/attribution.txt @@ -0,0 +1,228 @@ +Package: github.com/mattn/go-colorable + +License: MIT License + +Copyrights: + + +License Text: +https://opensource.org/licenses/MIT + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/kris-nova/lolgopher + +License: Apache License 2.0 + +Copyrights: + + +License Text: +http://www.apache.org/licenses/LICENSE-2.0 + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/aws/aws-sdk-go + +License: Apache License 2.0 + +Copyrights: + + +License Text: +http://www.apache.org/licenses/LICENSE-2.0 + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/aws/aws-sdk-go/internal/sync/singleflight + +License: BSD 3-Clause "New" or "Revised" License + +Copyrights: + + +License Text: +https://opensource.org/licenses/BSD-3-Clause + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/jmespath/go-jmespath + +License: Apache License 2.0 + +Copyrights: + + +License Text: +http://www.apache.org/licenses/LICENSE-2.0 + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/dchest/uniuri + +License: Creative Commons Zero v1.0 Universal + +Copyrights: + + +License Text: +https://creativecommons.org/publicdomain/zero/1.0/legalcode + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/PuerkitoBio/goquery + +License: BSD 3-Clause "New" or "Revised" License + +Copyrights: + + +License Text: +https://opensource.org/licenses/BSD-3-Clause + +------------------------------------------------------------------------------------------------------------------------------- + +Package: golang.org/x/net/html + +License: BSD 3-Clause "New" or "Revised" License + +Copyrights: + + +License Text: +https://opensource.org/licenses/BSD-3-Clause + +------------------------------------------------------------------------------------------------------------------------------- + +Package: gopkg.in/neurosnap/sentences.v1 + +License: MIT License + +Copyrights: + + +License Text: +https://opensource.org/licenses/MIT + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/kris-nova/logger + +License: Apache License 2.0 + +Copyrights: + + +License Text: +http://www.apache.org/licenses/LICENSE-2.0 + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/mattn/go-isatty + +License: MIT License + +Copyrights: + + +License Text: +https://opensource.org/licenses/MIT + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/olekukonko/tablewriter + +License: MIT License + +Copyrights: + + +License Text: +https://opensource.org/licenses/MIT + +------------------------------------------------------------------------------------------------------------------------------- + +Package: golang.org/x/sys + +License: BSD 3-Clause "New" or "Revised" License + +Copyrights: + + +License Text: +https://opensource.org/licenses/BSD-3-Clause + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/spf13/cobra + +License: Apache License 2.0 + +Copyrights: + + +License Text: +http://www.apache.org/licenses/LICENSE-2.0 + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/andybalholm/cascadia + +License: BSD 2-Clause "Simplified" License + +Copyrights: + + +License Text: +https://opensource.org/licenses/BSD-2-Clause + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/mattn/go-runewidth + +License: MIT License + +Copyrights: + + +License Text: +https://opensource.org/licenses/MIT + +------------------------------------------------------------------------------------------------------------------------------- + +Package: gopkg.in/yaml.v2 + +License: Apache License 2.0 + +Copyrights: + + +License Text: +http://www.apache.org/licenses/LICENSE-2.0 + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/fatih/color + +License: MIT License + +Copyrights: + + +License Text: +https://opensource.org/licenses/MIT + +------------------------------------------------------------------------------------------------------------------------------- + +Package: github.com/spf13/pflag + +License: BSD 3-Clause "New" or "Revised" License + +Copyrights: + + +License Text: +https://opensource.org/licenses/BSD-3-Clause + +------------------------------------------------------------------------------------------------------------------------------- + diff --git a/cmd/get.go b/cmd/get.go new file mode 100644 index 0000000..7cf418b --- /dev/null +++ b/cmd/get.go @@ -0,0 +1,253 @@ +package cmd + +import ( + "fmt" + "os" + "strings" + "time" + + awslocal "github.com/Optum/cloudig/pkg/aws" + "github.com/Optum/cloudig/pkg/cloudig" + + "github.com/kris-nova/logger" + "github.com/spf13/cobra" +) + +var ( + commentsFile string + roleARN string + output string + region string + pastDays string + details bool + ecrImageTag string + identityARNs string + identityTags string + includeUsage bool + includeErrors bool + includeCallerIdentity bool + absoluteTime string + relativeTime int +) + +// getCmd represents the get command +var getCmd = &cobra.Command{ + Use: "get trustedadvisor/awsconfig/inspector/health/ecrscan", + Short: "Get report findings", + ValidArgs: []string{"trustedadvisor", "awsconfig", "inspector", "health", "ecrscan"}, + Args: cobra.OnlyValidArgs, + Run: func(cmd *cobra.Command, args []string) { + if len(args) < 1 { + fmt.Println("missing subcommands") + os.Exit(1) + } + }, +} + +// reflectCmd represents the reflect command +var reflectCmd = &cobra.Command{ + Use: "reflect iam", + Short: "Reflect on IAM role permissions", + ValidArgs: []string{"iam"}, + Args: cobra.OnlyValidArgs, + Run: func(cmd *cobra.Command, args []string) { + if len(args) < 1 { + fmt.Println("missing subcommands") + os.Exit(1) + } + }, +} + +// trustedAdvisorCmd represents the get trustedadvisor command +var trustedAdvisorCmd = &cobra.Command{ + Use: "trustedadvisor", + Short: "Get AWS Trusted Advisor report findings", + Aliases: []string{"ta", "t"}, + + Run: func(cmd *cobra.Command, args []string) { + execute(&cloudig.TrustedAdvisorReport{}) + }, +} + +// awsConfigCmd represents the config command +var awsConfigCmd = &cobra.Command{ + Use: "awsconfig", + Short: "Get AWS Config report findings", + Aliases: []string{"ac", "a"}, + + Run: func(cmd *cobra.Command, args []string) { + execute(&cloudig.ConfigReport{}) + }, +} + +// inspectorCmd represents the inspector command +var inspectorCmd = &cobra.Command{ + Use: "inspector", + Short: "Get AWS Inspector report findings", + Aliases: []string{"inspect", "ins", "i"}, + + Run: func(cmd *cobra.Command, args []string) { + execute(&cloudig.InspectorReports{Helper: &cloudig.InspectorHelper{}}) + }, +} + +// healthCmd represents the get health command +var healthCmd = &cobra.Command{ + Use: "health", + Short: "Get AWS Health notifications' details", + Aliases: []string{"he", "h", "healthnotifications", "healthnotification"}, + + Run: func(cmd *cobra.Command, args []string) { + flags := struct { + Details bool + PastDays string + }{ + Details: details, + PastDays: pastDays, + } + + execute(&cloudig.HealthReport{ + Flags: flags, + }) + }, +} + +// ecrScanCmd represents the ecrscan command +var ecrScanCmd = &cobra.Command{ + Use: "ecrscan", + Short: "Get ECR Image Scan report findings", + Aliases: []string{"scan", "sc", "s"}, + Run: func(cmd *cobra.Command, args []string) { + execute(&cloudig.ImageScanReports{ + Flags: cloudig.ImageScanReportFlags{ + Tag: ecrImageTag, + Region: region, + }, + }) + }, +} + +// iamCmd represents the reflect IAM command +var iamCmd = &cobra.Command{ + Use: "iam", + Short: "Reflect on IAM Role permissions", + Aliases: []string{"i", "iamrole"}, + + Run: func(cmd *cobra.Command, args []string) { + + var roles []string + if identityARNs != "" { + roles = strings.Split(identityARNs, ",") + } + + // convert string "k1:v1,k2:v2" to map[string]string{"k1":"v1","k2":"v2"} + tags := make(map[string]string) + for _, v := range strings.Split(identityTags, ",") { + kv := strings.Split(v, ":") + if len(kv) == 2 { + tags[kv[0]] = kv[1] + } + } + + // if -u or -e is not provided both will be true, if one of them is provided then the other one is false + if !includeUsage && !includeErrors { + includeUsage = true + includeErrors = true + } + + // validate absolute-time + if absoluteTime != "" { + var startTime, endTime time.Time + errorMessage := "--absolute-time is wrong. It should be in the form 'startTime-endTime' 'mm/dd/yyyy-mm/dd/yyy' ex: '10/25/2020-10/31/2020'" + dates := strings.Split(absoluteTime, "-") + if len(dates) != 2 { + fmt.Println(errorMessage) + os.Exit(1) + } + startDate, endDate := dates[0], dates[1] + format := "01/02/2006" // mm/dd/yyyy format + var err error + // convert to time + startTime, err = time.Parse(format, startDate) + if err != nil { + fmt.Println(errorMessage) + os.Exit(1) + } + endTime, err = time.Parse(format, endDate) + if err != nil { + fmt.Println(errorMessage) + os.Exit(1) + } + if endTime.Before(startTime) { + fmt.Println(errorMessage) + os.Exit(1) + } + } + + execute(&cloudig.ReflectReport{ + Flags: cloudig.NewReflectFlags(region, roles, tags, includeUsage, includeErrors, includeCallerIdentity, absoluteTime, relativeTime), + }) + + }, +} + +func init() { + rootCmd.AddCommand(getCmd) + rootCmd.AddCommand(reflectCmd) + + getCmd.AddCommand(trustedAdvisorCmd) + getCmd.AddCommand(awsConfigCmd) + getCmd.AddCommand(inspectorCmd) + getCmd.AddCommand(healthCmd) + getCmd.AddCommand(ecrScanCmd) + reflectCmd.AddCommand(iamCmd) + + // Here you will define your flags and configuration settings. + rootCmd.PersistentFlags().StringVarP(&commentsFile, "cfile", "c", "comments.yaml", "Comments file name") + rootCmd.PersistentFlags().StringVar(&roleARN, "rolearn", "", "One or more role ARNs seperated by a comma [,]") + rootCmd.PersistentFlags().StringVarP(&output, "output", "o", "json", "Output of report. Options: [json, table, mdtable]. Default output is JSON") + rootCmd.PersistentFlags().StringVarP(®ion, "region", "r", "us-east-1", "AWS region to get results from") + rootCmd.PersistentFlags().IntVarP(&logger.Level, "verbose", "v", 3, "set log level, use 0 to silence, 1 for critical, 2 for warning, 3 for informational, 4 for debugging and 5 for debugging with AWS debug logging (default 3)") + // this is CLI , so turning of timestamp + logger.Timestamps = false + // healthCmd specific flags + healthCmd.PersistentFlags().BoolVarP(&details, "details", "d", false, "Flag to indicate level of printing for each notification (default false)") + healthCmd.PersistentFlags().StringVar(&pastDays, "pastdays", "", "Number of past days to get results from") + + // ecrScanCmd specific flags + ecrScanCmd.PersistentFlags().StringVar(&ecrImageTag, "tag", "", "Tag of ECR image(s) to report scan results.") + + // iamCmd specific flags + iamCmd.PersistentFlags().StringVarP(&identityARNs, "identity", "i", "", "One or more IAM Identities (users, groups, and roles) ARNs separated by a comma [,].Only role ARNs is supported today") + iamCmd.PersistentFlags().StringVarP(&identityTags, "identity-tags", "t", "", "Set of tags in form [key:value] separated by [,] to find the targeted IAM Identities. Only role ARN is supported today. Ignored when --identity is provided") + // if -u or -e is not provided both will be true, if one of them is provided then the other one is false + iamCmd.PersistentFlags().BoolVarP(&includeUsage, "usage", "u", false, "Reflect Identity usage data (default true, if --errors/-e is not explicitly provided)") + iamCmd.PersistentFlags().BoolVarP(&includeErrors, "errors", "e", false, "Reflect Identity error data (default true, if --usage/-u is not explicitly provided)") + iamCmd.PersistentFlags().BoolVar(&includeCallerIdentity, "caller-identity", false, "Include caller identity with the report(default false)") + iamCmd.PersistentFlags().StringVar(&absoluteTime, "absolute-time", "", "Specify both the start and end times for the time filter in the form 'startTime-endTime' 'mm/dd/yyyy-mm/dd/yyy' ex: '10/25/2020-10/31/2020'") + iamCmd.PersistentFlags().IntVar(&relativeTime, "relative-time", 1, "Specify a time filter relative to the current time in days. Default 1 day. Ignored when absolute-time is provided") +} + +func execute(report cloudig.Report) { + sess, err := awslocal.NewAuthenticatedSession(region) + if err != nil { + logger.Critical("error creating aws session: %v", err) + os.Exit(1) + } + + // example type should be "*cloudig.HealthReport", we are spliting the string to get "HealthReport" + rType := strings.Split(fmt.Sprintf("%T", report), ".")[1] + logger.Debug("all root level flags:\ncommentsFile: %s\nroleARN: %s\noutput: %s\nregion: %s\nlogLevel: %d\n", commentsFile, roleARN, output, region, logger.Level) + + if rType == "HealthReport" { + logger.Debug("all health command flags:\ndetails: %t\npastDays: %s\n", details, pastDays) + } + if rType == "ReflectReport" { + logger.Debug("all reflect command flags:\nidentityARNs: %s\nidentityTags: %s\nincludeUsage: %t\nincludeErrors: %t\nincludeCallerIdentity: %t\nabsoluteTime: %s\nrelativeTime: %d\n", identityARNs, identityTags, includeUsage, includeErrors, includeCallerIdentity, absoluteTime, relativeTime) + } + + err = cloudig.ProcessReport(sess, report, output, commentsFile, roleARN) + if err != nil { + logger.Critical("error creating '%s': %v", rType, err) + } +} diff --git a/cmd/root.go b/cmd/root.go new file mode 100644 index 0000000..9b528f4 --- /dev/null +++ b/cmd/root.go @@ -0,0 +1,57 @@ +package cmd + +/* +Copyright © 2019 NAME HERE + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +import ( + "fmt" + "os" + + "github.com/spf13/cobra" +) + +// Makefile uses flags to set version variable +// Makefile version is the superior source of truth for versioning +// However if the make commands are run without this flags, this backup is used +var version = "local" + +// rootCmd represents the base command when called without any subcommands +var rootCmd = &cobra.Command{ + Use: "cloudig [VERB] [NOUN] --FLAG", + Long: `cloudig is a CLI tool that generates reports from various cloud sources and user-provided comments + +Supported sources are: + +* AWS Trusted Advisor: https://aws.amazon.com/premiumsupport/trustedadvisor/ +* AWS Config: https://aws.amazon.com/config/ +* Amazon Inspector: https://aws.amazon.com/inspector/ +* AWS Health: https://aws.amazon.com/premiumsupport/technology/personal-health-dashboard/ +* AWS ECR: https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html +* AWS IAM Reflect: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html`, + + // Version is set at compile time in parallel to rootCmd, so we need to read version after + Version: *(&version), +} + +// Execute adds all child commands to the root command and sets flags appropriately. +// This is called by main.main(). It only needs to happen once to the rootCmd. +func Execute() { + rootCmd.SetVersionTemplate("Beta release: {{ .Version }}\n") + if err := rootCmd.Execute(); err != nil { + fmt.Println(err) + os.Exit(1) + } +} diff --git a/comments.yaml b/comments.yaml new file mode 100644 index 0000000..b7f470c --- /dev/null +++ b/comments.yaml @@ -0,0 +1,23 @@ +- accountid: "111111111111" + ta-findings: + - SECURITY-IAM_Use: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM" + config-findings: + - IAM_POLICY_BLACKLISTED_CHECK: "**EXCEPTION:** Removed access policy since the default account uses this policy. Future enhancement would be to create a Custom Rule that only admin account can use this policy." + inspector-findings: + - CIS_Operating_System_Security_Configuration_Benchmarks-1.0: "**EXCEPTION:** Temporary, will be fixed in next release" + health-findings: + - AWS_RDS_SECURITY_NOTIFICATION: "**EXCEPTION:** Temporary, will be fixed in next release" + reflect-iam-findings: + - arn:aws:iam::111111111111:role/example-role: "**WORK_IN_PROGRESS:** Lot of unnecessary permissions" +- accountid: "222222222222" + ta-findings: + - SECURITY-IAM_Use: "**EXCEPTION:** We use IAM roles to manage resources in AWS. No users/groups created in IAM" + - FAULT_TOLERANCE-Amazon_EBS_Snapshots: "**EXCEPTION:** We do not persist any critical data on EC2 attached EBS. Data present in these disks are ephemeral in nature" + config-findings: + - ATTACHED_INTERNET_GATEWAY_CHECK: "**EXCEPTION:** Flags VPCs that have an Internet Gateway attached which is currently required. Future enhancement would be to check VPC with all of its SUBNET open to IGW" + - IAM_POLICY_BLACKLISTED_CHECK: "**EXCEPTION:** Removed access policy since the default account uses this policy. Future enhancement would be to create a Custom Rule that only admin account can use this policy." +- accountid: "333333333333" + ecr-findings: + - 333333333333.dkr.ecr.us-east-1.amazonaws.com/admin/example-app:v1.0.0: "EXCEPTION Patch will applied this weekend" + - ALL:v1.2.0: "EXCEPTION Patch is coming tomorrow" + - ALL:prod-canary: "EXCEPTION Patch is coming tomorrow" diff --git a/doc/awsconfig.md b/doc/awsconfig.md new file mode 100644 index 0000000..01f5ee1 --- /dev/null +++ b/doc/awsconfig.md @@ -0,0 +1,26 @@ +AWS Config: `awsconfig`, `ac`, `a` + +Example: `cloudig get ac --region us-east-1 -o table` + +Output (ASCII Table) + +```txt +Report Time: 11 Oct 19 13:27 CDT + ++--------------+---------------------------------------------+--------------------------------+-------------+ +| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | ++--------------+---------------------------------------------+--------------------------------+-------------+ +| 123456789101 | ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK | Resource Type: | NEW_FINDING | +| | | AWS::EC2::SecurityGroup | | +| | | sg-111111 | | +| | | sg-222222 | | ++--------------+---------------------------------------------+--------------------------------+-------------+ +| 123456789101 | ATTACHED_INTERNET_GATEWAY_CHECK | Resource Type: AWS::EC2::VPC | NEW_FINDING | +| | | vpc-11111 | | +| | | vpc-22222 vpc-333333 | | ++--------------+---------------------------------------------+--------------------------------+-------------+ +| 123456789101 | CF_WITH_S3_ORIGIN_ONLY_ALLOWS_CF_READ_CHECK | Resource Type: | NEW_FINDING | +| | | AWS::CloudFront::Distribution | | +| | | {CFDistroID} {CFDistroID} | | ++--------------+---------------------------------------------+--------------------------------+-------------+ +``` diff --git a/doc/ecrscan.md b/doc/ecrscan.md new file mode 100644 index 0000000..8c42a2b --- /dev/null +++ b/doc/ecrscan.md @@ -0,0 +1,54 @@ +AWS ECR Image scan findings : `ecrscan`, `scan`, `s` + +Example: `cloudig get scan --region us-east-1 -o json` + +Sample Output(JSON) + +```json +{ + "findings": [ + { + "accountId": "333333333333", + "imageDigest": "sha256:88d5da4609681df482d51c4e898d107317c32bd3c4951793138570cc18c1294d", + "imageTag": "latest", + "repositoryName": "dig/pingfederate-server", + "region": "us-east-1", + "comments": "NEW_FINDING", + "imageFindingsCount": { + "HIGH": 1 + } + }, + { + "accountId": "333333333333", + "imageDigest": "sha256:99d0ab34e24a87884b104e76dea5d917ab026c0cfc352bc9cf2665d5d70f973a", + "imageTag": "v0.0.16", + "repositoryName": "dig/service-gateway", + "region": "us-east-1", + "comments": "**EXCEPTION** Patch will applied this weekend", + "imageFindingsCount": { + "HIGH": 5, + "MEDIUM": 4 + } + } + ] +} +``` + +esrscan image will also take optional parameter tag as first argument: + +``` +cloudig get scan --tag -o mdtable + +Example: +cloudig get scan --tag latest -o mdtable +``` + +```markdown +Sample output with mdtable format, with specific tag "latest" + +| ACCOUNT ID | REGION | REPOSITORY NAME | TAG | VULNERABILITIES(COUNT) | COMMENTS | +| ------------ | --------- | ----------------------------------- | ------ | ---------------------- | ----------- | +| 111111111111 | us-east-1 | temporary-custom-terraform-provider | latest | LOW: 6 | NEW_FINDING | +| | | | | HIGH: 18 | | +| | | | | MEDIUM: 19 | | +``` diff --git a/doc/health.md b/doc/health.md new file mode 100644 index 0000000..61da4ce --- /dev/null +++ b/doc/health.md @@ -0,0 +1,42 @@ +Health: `health`, `he`, `h` + +Example: `cloudig get health --cfile my-comments.yaml --output mdtable` + +Output (Markdown Table) + +```markdown +| ACCOUNT ID | EVENT TYPE CODE | REGION | STATUS CODE | EVENT DESCRIPTION | AFFECTED RESOURCES | COMMENTS | +| ------------ | ---------------------------- | --------- | ----------- | ------------------------------ | -------------------------------- | ----------- | +| 111111111111 | Rds Operational Notification | us-east-2 | open | On December 4, 2020, we | dig-global-stage-aurora-cluster, | NEW_FINDING | +| | | | | sent an email that contained | dig-global-dev-aurora-cluster | | +| | | | | errors in formatting. We have | | | +| | | | | corrected these issues and | | | +| | | | | are resending the email in | | | +| | | | | its entirety following this | | | +| | | | | paragraph. We are sorry for | | | +| | | | | any inconvenience our mistake | | | +| | | | | may have caused.Our records | | | +| | | | | indicate that you have one | | | +| | | | | or more Aurora MySQL database | | | +| | | | | instances which are not | | | +| | | | | running the latest preferred | | | +| | | | | minor version of Aurora MySQL | | | +| | | | | (with MySQL 5.6 compatibility) | | | +| | | | | available on RDS. | | | +| 111111111111 | Ecs Operational Notification | us-east-1 | open | A software update has been | dig-dev-kafka-service-0 | NEW_FINDING | +| | | | | deployed to the AWS Fargate | / dig-dev-kafka-cluster, | | +| | | | | infrastructure. Your impacted | dig-dev-kafka-service-2 | | +| | | | | Amazon ECS services in the | / dig-dev-kafka-cluster, | | +| | | | | US-EAST-1 Region are listed | dev-exodos / dev-exodos, | | +| | | | | in your 'Affected resources' | dig-dev-kafka-service-1 | | +| | | | | tab in the format Service / | / dig-dev-kafka-cluster, | | +| | | | | Cluster.This software update | stage-exodos / stage-exodos, | | +| | | | | requires that the tasks in | okra-exodos / okra-exodos, | | +| | | | | your affected services be | dig-stage-kafka-service-1 | | +| | | | | relaunched by forcing a new | / dig-stage-kafka-cluster, | | +| | | | | service deployment. You can | dig-stage-kafka-service-0 | | +| | | | | update your service and force | / dig-stage-kafka-cluster, | | +| | | | | a new service deployment using | dig-stage-kafka-service-2 / | | +| | | | | the AWS Management Console, | dig-stage-kafka-cluster | | +| | | | | AWS SDKs, or the AWS CLI. | +``` diff --git a/doc/inspector.md b/doc/inspector.md new file mode 100644 index 0000000..bfe3ef7 --- /dev/null +++ b/doc/inspector.md @@ -0,0 +1,23 @@ +Inspector: `inspector`, `ins`, `i` + +Example: `cloudig get inspector --cfile my-comments.yaml --output mdtable` + +Output (Markdown Table) + +```markdown +Report Time: 11 Oct 19 13:32 CDT + +| ACCOUNT ID | TEMPLATE NAME | RULE PACKAGES | HIGH | MEDIUM | LOW | INFORMATIONAL | COMMENTS | +| ------------ | --------------- | ----------------------------- | ---- | ------ | --- | ------------- | -------------------------- | +| 111111111111 | test-once-dev | CIS Operating System Security | 267 | 0 | 0 | 24 | **EXCEPTION:** Description | +| | | Configuration Benchmarks-1.0 | | | | | here | +| 111111111111 | test-once-dev | Common Vulnerabilities and | 0 | 0 | 0 | 0 | | +| | | Exposures-1.1 | | | | | | +| 111111111111 | test-once-dev | Security Best Practices-1.0 | 0 | 3 | 0 | 0 | NEW_FINDING | +| 111111111111 | k8s_weekly_scan | Network Reachability-1.1 | 0 | 0 | 0 | 0 | | + +| ACCOUNT ID | AMI | AGE | +| ------------ | ------------------------------ | ------- | +| 111111111111 | amazon-eks-node-1.16-v20201211 | 25 days | +| | | | +``` diff --git a/doc/reflectiam.md b/doc/reflectiam.md new file mode 100644 index 0000000..e3babb8 --- /dev/null +++ b/doc/reflectiam.md @@ -0,0 +1,438 @@ +Reflect: `cloudig reflect iam` + +Examples: + +- Reflect on single IAM role based on last 4 days of CloudTrail data: + + `cloudig reflect iam -i arn:aws:iam::111111111111:role/web-gateway-greencherry-dev --relative-time 4` + +- Reflect on multiple IAM roles between specific dates: + + `cloudig reflect iam -i 'arn:aws:iam::111111111111:role/web-gateway-greencherry-dev,arn:aws:iam::111111111111:role/admin-gateway-greencherry-dev' --absolute-time '11/20/2020-12/04/2020' -o table` + + ``` + [ℹ] reading comments from file comments.yaml + [ℹ] working on reflect report for account: 111111111111 + [ℹ] getting the s3 prefix associated with the CloudTrail + [ℹ] constructing the Athena table metadata form the s3 prefix + [ℹ] finding the existing Athena table from the constructed metadata + [ℹ] found the existing Athena table: default.reflect_cloudtrail_gxev4 + [ℹ] populating findings for roles + [✔] successfully populated the findings for roles + [ℹ] finding the actual permission for the roles + [✔] reflecting on account 111111111111 took 44.725057955s + [✿] report Time: 21 Dec 20 12:47 CST + +--------------+--------------------------------------------------------------+------------------------------+-------------------------------------+--------------------------------+ + | ACCOUNT ID | IAM IDENTITY | ACCESS DETAILS | ACTUAL PERMISSIONS | COMMENTS | + +--------------+--------------------------------------------------------------+------------------------------+-------------------------------------+--------------------------------+ + | 111111111111 | arn:aws:iam::111111111111:role/admin-gateway-greencherry-dev | kms.amazonaws.com/Decrypt:2 | kms:ListKeys kms:ListGrants | NEW_FINDING | + | | | | kms:GenerateDataKeyWithoutPlaintext | | + | | | | kms:GenerateDataKey kms:Encrypt | | + | | | | kms:DescribeKey kms:Decrypt | | + | | | | events:PutEvents | | + +--------------+--------------------------------------------------------------+------------------------------+-------------------------------------+--------------------------------+ + | 111111111111 | arn:aws:iam::111111111111:role/web-gateway-greencherry-dev | kms.amazonaws.com/Decrypt:10 | kms:ListKeys kms:ListGrants | **WORK_IN_PROGRESS:** Lot of | + | | | | kms:GenerateDataKeyWithoutPlaintext | unnecessary permissions | + | | | | kms:GenerateDataKey kms:Encrypt | | + | | | | kms:DescribeKey kms:Decrypt | | + | | | | events:PutEvents | | + +--------------+--------------------------------------------------------------+------------------------------+-------------------------------------+--------------------------------+ + ``` + +* Reflect on usage of a specific role with caller identity: + + `cloudig reflect iam -i 'arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass' --caller-identity -o mdtable --relative-time 5` + +``` +| ACCOUNT ID | IAM IDENTITY | ACCESS DETAILS | ACTUAL PERMISSIONS | COMMENTS | +|--------------|-------------------------------------------------------------------------------------|----------------------------------------------------------------|--------------------------------|-------------| +| 111111111111 | arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass@someuser@company.com | ecr.amazonaws.com/BatchCheckLayerAvailability:63 | The role with name | NEW_FINDING | +| | | sts.amazonaws.com/GetCallerIdentity:39 | AWS_111111111111_BreakGlass | | +| | | ecr.amazonaws.com/UploadLayerPart:33 | cannot be found. | | +| | | kms.amazonaws.com/Decrypt:28 | | | +| | | ecr.amazonaws.com/CompleteLayerUpload:23 | | | +| | | ecr.amazonaws.com/InitiateLayerUpload:23 | | | +| | | health.amazonaws.com/DescribeEventAggregates:13 | | | +| | | route53.amazonaws.com/GetHostedZone:2 | | | +| | | route53.amazonaws.com/ListTagsForResource:2 | | | +| | | cognito-sync.amazonaws.com/GetIdentityPoolConfiguration:2 | | | +| | | cognito-identity.amazonaws.com/DescribeIdentityPool:2 | | | +| | | ecr.amazonaws.com/GetAuthorizationToken:2 | | | +| | | lambda.amazonaws.com/ListFunctions20150331:2 | | | +| | | route53.amazonaws.com/GetHostedZoneCount:2 | | | +| | | cognito-identity.amazonaws.com/GetIdentityPoolRoles:2 | | | +| | | cognito-identity.amazonaws.com/ListIdentityPools:2 | | | +| | | cognito-sync.amazonaws.com/DescribeIdentityPoolUsage:2 | | | +| | | ecr.amazonaws.com/PutImage:2 | | | +| | | route53.amazonaws.com/ListResourceRecordSets:2 | | | +| | | iam.amazonaws.com/GetRole:2 | | | +| | | route53.amazonaws.com/ListQueryLoggingConfigs:2 | | | +| | | sns.amazonaws.com/ListPlatformApplications:1 | | | +| | | route53domains.amazonaws.com/ListDomains:1 | | | +| | | iam.amazonaws.com/ListRoles:1 | | | +| | | route53.amazonaws.com/ListTrafficPolicies:1 | | | +| | | route53domains.amazonaws.com/ListOperations:1 | | | +| | | iam.amazonaws.com/ListSAMLProviders:1 | | | +| | | route53.amazonaws.com/ChangeResourceRecordSets:1 | | | +| | | kinesis.amazonaws.com/ListStreams:1 | | | +| | | cognito-sync.amazonaws.com/GetBulkPublishDetails:1 | | | +| | | ec2.amazonaws.com/DescribeVpcs:1 | | | +| | | iam.amazonaws.com/ListOpenIDConnectProviders:1 | | | +| | | route53.amazonaws.com/GetHealthCheckCount:1 | | | +| | | route53.amazonaws.com/ListHostedZonesByName:1 | | | +| | | route53.amazonaws.com/GetTrafficPolicyInstanceCount:1 | | | +| | | cognito-sync.amazonaws.com/GetCognitoEvents:1 | | | +| 111111111111 | arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass@otheruser@company.com | s3.amazonaws.com/ListObjects:5 | The role with name | NEW_FINDING | +| | | sts.amazonaws.com/GetCallerIdentity:4 | AWS_111111111111_BreakGlass | | +| | | s3.amazonaws.com/GetObject:4 | cannot be found. | | +| | | s3.amazonaws.com/ListBuckets:1 | | | +| | | s3.amazonaws.com/PutObject:1 | | | +``` + +- Reflect on set of roles based on tags: + + `cloudig reflect iam -t 'terraform:True' --caller-identity -o mdtable --relative-time 5` + +- Reflect on access denied errors for all roles: + + `cloudig reflect iam -i 'arn:aws:iam::111111111111:role/lp-iam-prismacloud' --errors` + +``` +[ℹ] reading comments from file comments.yaml +[ℹ] working on reflect report for account: 111111111111 +[ℹ] getting the s3 prefix associated with the CloudTrail +[ℹ] constructing the Athena table metadata form the s3 prefix +[ℹ] finding the existing Athena table from the constructed metadata +[ℹ] found the existing Athena table: default.reflect_cloudtrail_gxev4 +[ℹ] populating findings for roles +[✔] successfully polpulated the findings for roles +[ℹ] finding the actual permission for the roles +[✔] reflecting on account 111111111111 took 19.180778089s +{ + "findings": [ + { + "accountId": "111111111111", + "IAMIdentity": "arn:aws:iam::111111111111:role/lp-iam-prismacloud", + "accessDetails": [ + { + "IAMAction": "wafv2.amazonaws.com/GetWebACL/AccessDenied", + "UsageCount": 612 + }, + { + "IAMAction": "inspector.amazonaws.com/DescribeAssessmentRuns/AccessDenied", + "UsageCount": 268 + }, + { + "IAMAction": "kms.amazonaws.com/DescribeKey/AccessDenied", + "UsageCount": 103 + }, + { + "IAMAction": "dms.amazonaws.com/DescribeCertificates/AccessDenied", + "UsageCount": 34 + }, + { + "IAMAction": "directconnect.amazonaws.com/DescribeConnections/AccessDenied", + "UsageCount": 34 + } + ], + "permissionSet": [ + "iam:listSAMLProviders", + "iam:getSAMLProvider", + "iam:SimulatePrincipalPolicy", + "iam:SimulateCustomPolicy", + "iam:ListVirtualMFADevices", + "iam:ListUsers", + "iam:ListUserTags", + "iam:ListUserPolicies", + "iam:ListServerCertificates", + "iam:ListSSHPublicKeys", + "iam:ListRoles", + "iam:ListRolePolicies", + "iam:ListPolicyVersions", + "iam:ListPolicies", + "iam:ListMFADevices", + "iam:ListInstanceProfilesForRole", + "iam:ListGroupsForUser", + "iam:ListGroups", + "iam:ListGroupPolicies", + "iam:ListEntitiesForPolicy", + "iam:ListAttachedUserPolicies", + "iam:ListAttachedRolePolicies", + "iam:ListAttachedGroupPolicies", + "iam:ListAccessKeys", + "iam:GetUserPolicy", + "iam:GetServiceLastAccessedDetails", + "iam:GetRolePolicy", + "iam:GetPolicyVersion", + "iam:GetGroupPolicy", + "iam:GetCredentialReport", + "iam:GetAccountSummary", + "iam:GetAccountPasswordPolicy", + "iam:GetAccountAuthorizationDetails", + "iam:GenerateServiceLastAccessedDetails", + "iam:GenerateCredentialReport", + "guardduty:ListFindings", + "guardduty:ListDetectors", + "guardduty:GetFindings", + "guardduty:GetDetector", + "glue:GetSecurityConfigurations", + "glue:GetConnections", + "glacier:ListVaults", + "glacier:ListTagsForVault", + "glacier:GetVaultNotifications", + "glacier:GetVaultLock", + "glacier:GetVaultAccessPolicy", + "glacier:GetDataRetrievalPolicy", + "fms:ListPolicies", + "fms:ListComplianceStatus", + "firehose:ListTagsForDeliveryStream", + "firehose:ListDeliveryStreams", + "firehose:DescribeDeliveryStream", + "es:ListTags", + "es:ListDomainNames", + "es:DescribeElasticsearchDomains", + "elasticmapreduce:ListSecurityConfigurations", + "elasticmapreduce:ListClusters", + "elasticmapreduce:GetBlockPublicAccessConfiguration", + "elasticmapreduce:DescribeSecurityConfiguration", + "elasticmapreduce:DescribeCluster", + "elasticloadbalancing:DescribeTargetHealth", + "elasticloadbalancing:DescribeTargetGroups", + "elasticloadbalancing:DescribeTags", + "elasticloadbalancing:DescribeSSLPolicies", + "elasticloadbalancing:DescribeLoadBalancers", + "elasticloadbalancing:DescribeLoadBalancerPolicies", + "elasticloadbalancing:DescribeLoadBalancerAttributes", + "elasticloadbalancing:DescribeListeners", + "elasticfilesystem:DescribeTags", + "elasticfilesystem:DescribeMountTargets", + "elasticfilesystem:DescribeMountTargetSecurityGroups", + "elasticfilesystem:DescribeFileSystems", + "elasticbeanstalk:ListTagsForResource", + "elasticbeanstalk:DescribeEnvironments", + "elasticbeanstalk:DescribeEnvironmentResources", + "elasticbeanstalk:DescribeConfigurationSettings", + "elasticache:ListTagsForResource", + "elasticache:DescribeSnapshots", + "elasticache:DescribeReservedCacheNodesOfferings", + "elasticache:DescribeReservedCacheNodes", + "elasticache:DescribeReplicationGroups", + "elasticache:DescribeCacheSubnetGroups", + "elasticache:DescribeCacheSecurityGroups", + "elasticache:DescribeCacheParameterGroups", + "elasticache:DescribeCacheEngineVersions", + "elasticache:DescribeCacheClusters", + "eks:ListTagsForResource", + "eks:ListClusters", + "eks:DescribeCluster", + "ecs:ListTasks", + "ecs:ListTaskDefinitions", + "ecs:ListTagsForResource", + "ecs:ListServices", + "ecs:ListClusters", + "ecs:DescribeTasks", + "ecs:DescribeTaskDefinition", + "ecs:DescribeServices", + "ecr:ListTagsForResource", + "ecr:GetRepositoryPolicy", + "ecr:GetLifecyclePolicy", + "ecr:DescribeRepositories", + "ecr:DescribeImages", + "ec2:DescribeVpnGateways", + "ec2:DescribeVpnConnections", + "ec2:DescribeVpcs", + "ec2:DescribeVpcPeeringConnections", + "ec2:DescribeVpcEndpoints", + "ec2:DescribeVolumes", + "ec2:DescribeTransitGateways", + "ec2:DescribeTags", + "ec2:DescribeSubnets", + "ec2:DescribeSnapshots", + "ec2:DescribeSnapshotAttribute", + "ec2:DescribeSecurityGroups", + "ec2:DescribeRouteTables", + "ec2:DescribeRegions", + "ec2:DescribeNetworkInterfaces", + "ec2:DescribeNetworkInterfaceAttribute", + "ec2:DescribeNetworkAcls", + "ec2:DescribeNatGateways", + "ec2:DescribeKeyPairs", + "ec2:DescribeInternetGateways", + "ec2:DescribeInstances", + "ec2:DescribeInstanceStatus", + "ec2:DescribeImages", + "ec2:DescribeFlowLogs", + "ec2:DescribeDhcpOptions", + "ec2:DescribeCustomerGateways", + "ec2:DescribeAddresses", + "ec2:DescribeAccountAttributes", + "dynamodb:ListTagsOfResource", + "dynamodb:ListTables", + "dynamodb:DescribeTable", + "ds:DescribeDirectories", + "dms:ListTagsForResource", + "dms:DescribeReplicationInstances", + "dms:DescribeEndpoints", + "directconnect:DescribeDirectConnectGateways", + "config:DescribeDeliveryChannels", + "config:DescribeConfigurationRecorders", + "config:DescribeConfigurationRecorderStatus", + "config:BatchGetResourceConfig", + "config:BatchGetAggregateResourceConfig", + "cognito-idp:ListUserPools", + "cognito-idp:ListTagsForResource", + "cognito-identity:ListTagsForResource", + "cognito-identity:ListIdentityPools", + "cloudwatch:ListTagsForResource", + "cloudwatch:ListMetrics", + "cloudwatch:GetMetricData", + "cloudwatch:DescribeAlarms", + "cloudtrail:LookupEvents", + "cloudtrail:ListTags", + "cloudtrail:GetTrailStatus", + "cloudtrail:GetEventSelectors", + "cloudtrail:DescribeTrails", + "cloudsearch:DescribeDomains", + "cloudfront:ListTagsForResource", + "cloudfront:ListDistributions", + "cloudfront:GetDistributionConfig", + "cloudformation:ListStacks", + "cloudformation:ListStackResources", + "cloudformation:GetTemplate", + "cloudformation:GetStackPolicy", + "cloudformation:DescribeStacks", + "cloudformation:DescribeStackResources", + "autoscaling:DescribeLaunchConfigurations", + "autoscaling:DescribeAutoScalingGroups", + "apigateway:GET", + "acm:ListTagsForCertificate", + "acm:ListCertificates", + "acm:DescribeCertificate", + "workspaces:DescribeWorkspaces", + "workspaces:DescribeWorkspaceDirectories", + "workspaces:DescribeTags", + "wafv2:ListWebACLs", + "wafv2:ListTagsForResource", + "wafv2:ListResourcesForWebACL", + "waf:ListWebACLs", + "waf:ListTagsForResource", + "waf:GetWebACL", + "waf:GetLoggingConfiguration", + "waf-regional:ListWebACLs", + "waf-regional:ListTagsForResource", + "waf-regional:ListResourcesForWebACL", + "tag:GetTagKeys", + "tag:GetResources", + "ssm:ListTagsForResource", + "ssm:ListDocuments", + "ssm:GetParameters", + "ssm:DescribeParameters", + "sqs:listQueueTags", + "sqs:SendMessage", + "sqs:ListQueues", + "sqs:GetQueueAttributes", + "sns:ListTopics", + "sns:ListTagsForResource", + "sns:ListSubscriptionsByTopic", + "sns:ListSubscriptions", + "sns:ListPlatformApplications", + "sns:GetTopicAttributes", + "sns:GetSubscriptionAttributes", + "secretsmanager:ListSecrets", + "secretsmanager:GetResourcePolicy", + "secretsmanager:DescribeSecret", + "sagemaker:ListTags", + "sagemaker:ListNotebookInstances", + "sagemaker:ListEndpoints", + "sagemaker:DescribeNotebookInstance", + "sagemaker:DescribeEndpoint", + "s3:ListBucketByTags", + "s3:ListAllMyBuckets", + "s3:GetObjectVersionAcl", + "s3:GetObjectAcl", + "s3:GetLifecycleConfiguration", + "s3:GetEncryptionConfiguration", + "s3:GetBucketWebsite", + "s3:GetBucketVersioning", + "s3:GetBucketTagging", + "s3:GetBucketPublicAccessBlock", + "s3:GetBucketPolicyStatus", + "s3:GetBucketPolicy", + "s3:GetBucketLogging", + "s3:GetBucketLocation", + "s3:GetBucketAcl", + "s3:GetAccountPublicAccessBlock", + "route53domains:ListTagsForDomain", + "route53domains:ListOperations", + "route53domains:ListDomains", + "route53domains:GetOperationDetail", + "route53domains:GetDomainDetail", + "route53:ListTagsForResource", + "route53:ListResourceRecordSets", + "route53:ListHostedZones", + "route53:ListDomains", + "redshift:DescribeLoggingStatus", + "redshift:DescribeClusters", + "redshift:DescribeClusterParameters", + "rds:ListTagsForResource", + "rds:DescribeEventSubscriptions", + "rds:DescribeDBSnapshots", + "rds:DescribeDBSnapshotAttributes", + "rds:DescribeDBParameters", + "rds:DescribeDBParameterGroups", + "rds:DescribeDBInstances", + "rds:DescribeDBClusters", + "rds:DescribeDBClusterSnapshots", + "rds:DescribeDBClusterSnapshotAttributes", + "ram:ListResources", + "ram:ListPrincipals", + "ram:GetResourceShares", + "organizations:DescribeOrganization", + "mq:ListBrokers", + "mq:DescribeBroker", + "logs:ListTagsLogGroup", + "logs:GetLogEvents", + "logs:FilterLogEvents", + "logs:DescribeMetricFilters", + "logs:DescribeLogStreams", + "logs:DescribeLogGroups", + "lambda:ListTags", + "lambda:ListLayers", + "lambda:ListLayerVersions", + "lambda:ListFunctions", + "lambda:GetPolicy", + "lambda:GetLayerVersionPolicy", + "kms:ListResourceTags", + "kms:ListKeys", + "kms:ListKeyPolicies", + "kms:ListAliases", + "kms:GetKeyRotationStatus", + "kms:GetKeyPolicy", + "kms:DescribeKey", + "kinesisanalytics:ListApplications", + "kinesis:ListTagsForStream", + "kinesis:ListStreams", + "kinesis:DescribeStream", + "inspector:ListTagsForResource", + "inspector:ListRulesPackages", + "inspector:ListFindings", + "inspector:ListExclusions", + "inspector:ListEventSubscriptions", + "inspector:ListAssessmentTemplates", + "inspector:ListAssessmentTargets", + "inspector:ListAssessmentRuns", + "inspector:ListAssessmentRunAgents", + "inspector:DescribeRulesPackages", + "inspector:DescribeFindings", + "inspector:DescribeAssessmentTemplates" + ], + "comments": "NEW_FINDING" + } + ], + "reportTime": "21 Dec 20 13:07 CST" +} +``` + +- Reflect on all IAM roles: + +`cloudig reflect iam` diff --git a/doc/trustedadvisor.md b/doc/trustedadvisor.md new file mode 100644 index 0000000..92c3e39 --- /dev/null +++ b/doc/trustedadvisor.md @@ -0,0 +1,61 @@ +Trusted Advisor: `trustedadvisor`, `ta`, `t` + +Example: `cloudig get ta --rolearn arn:aws:iam::678910:role/cloudig` + +Output (JSON) + +```json +{ + "findings": [ + { + "accountId": "123456", + "category": "COST_OPTIMIZING", + "name": "Low Utilization Amazon EC2 Instances", + "description": "Checks the Amazon Elastic Compute Cloud (Amazon EC2) instances that were running at any time during the last 14 days and alerts you if the daily CPU utilization was 10% or less and network I/O was 5 MB or less on 4 or more days. Running instances generate hourly usage charges. Although some scenarios can result in low utilization by design, you can often lower your costs by managing the number and size of your instances.", + "status": "warning", + "resourcesSummary": { + "ResourcesFlagged": 16, + "ResourcesIgnored": 0, + "ResourcesProcessed": 37, + "ResourcesSuppressed": 0 + }, + "flaggedResources": [ + "i-0b18439757faf088a", + "i-095d0079d8546fd8a", + "i-0c5b586ec7e9d7eac", + "i-0e83db48d6de8f40b", + "i-008cceaa442471ec0", + "i-00699354adf9984ad", + "i-076d00ae185881b57", + "i-06faf0349948904c2", + "i-0baaf4989f05861aa", + "i-05663b1bc7e34230f", + "i-0928ccca5a6be3bab", + "i-0bd17acfcd8fd0545", + "i-0a23e343bb9fceb02", + "i-05b2809ba8bdd0b2c", + "i-04ebe8cc56724dda7", + "i-00ea85d920e9dd8cf" + ], + "comments": "NEW_FINDING" + }, + { + "accountId": "678910", + "category": "SECURITY", + "name": "IAM Use", + "description": "Checks for your use of AWS Identity and Access Management (IAM). You can use IAM to create users, groups, and roles in AWS, and you can use permissions to control access to AWS resources.", + "status": "warning", + "resourcesSummary": { + "ResourcesFlagged": 1, + "ResourcesIgnored": 0, + "ResourcesProcessed": 1, + "ResourcesSuppressed": 0 + }, + "flaggedResources": [ + "NA" + ], + "comments": "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM" + }, + ], + "reportTime": "08 Oct 19 10:44 CDT" +``` diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..f6e60d3 --- /dev/null +++ b/go.mod @@ -0,0 +1,25 @@ +module github.com/Optum/cloudig + +go 1.16 + +require ( + github.com/PuerkitoBio/goquery v1.5.0 + github.com/aws/aws-sdk-go v1.35.2 + github.com/dchest/uniuri v0.0.0-20200228104902-7aecb25e1fe5 + github.com/fatih/color v1.10.0 // indirect + github.com/go-test/deep v1.0.7 + github.com/golang/mock v1.4.4 + github.com/kr/pretty v0.1.0 // indirect + github.com/kris-nova/logger v0.0.0-20181127235838-fd0d87064b06 + github.com/kris-nova/lolgopher v0.0.0-20180124180951-14d43f83481a // indirect + github.com/mattn/go-runewidth v0.0.4 // indirect + github.com/neurosnap/sentences v1.0.6 // indirect + github.com/olekukonko/tablewriter v0.0.1 + github.com/spf13/cobra v0.0.5 + github.com/stretchr/testify v1.4.0 + golang.org/x/net v0.0.0-20201021035429-f5854403a974 // indirect + golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c // indirect + gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect + gopkg.in/neurosnap/sentences.v1 v1.0.6 + gopkg.in/yaml.v2 v2.3.0 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..651771c --- /dev/null +++ b/go.sum @@ -0,0 +1,105 @@ +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/PuerkitoBio/goquery v1.5.0 h1:uGvmFXOA73IKluu/F84Xd1tt/z07GYm8X49XKHP7EJk= +github.com/PuerkitoBio/goquery v1.5.0/go.mod h1:qD2PgZ9lccMbQlc7eEOjaeRlFQON7xY8kdmcsrnKqMg= +github.com/andybalholm/cascadia v1.0.0 h1:hOCXnnZ5A+3eVDX8pvgl4kofXv2ELss0bKcqRySc45o= +github.com/andybalholm/cascadia v1.0.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y= +github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= +github.com/aws/aws-sdk-go v1.35.2 h1:qK+noh6b9KW+5CP1NmmWsQCUbnzucSGrjHEs69MEl6A= +github.com/aws/aws-sdk-go v1.35.2/go.mod h1:H7NKnBqNVzoTJpGfLrQkkD+ytBA93eiDYi/+8rV9s48= +github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= +github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= +github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dchest/uniuri v0.0.0-20200228104902-7aecb25e1fe5 h1:RAV05c0xOkJ3dZGS0JFybxFKZ2WMLabgx3uXnd7rpGs= +github.com/dchest/uniuri v0.0.0-20200228104902-7aecb25e1fe5/go.mod h1:GgB8SF9nRG+GqaDtLcwJZsQFhcogVCJ79j4EdT0c2V4= +github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg= +github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= +github.com/go-test/deep v1.0.7 h1:/VSMRlnY/JSyqxQUzQLKVMAskpY/NZKFA5j2P+0pP2M= +github.com/go-test/deep v1.0.7/go.mod h1:QV8Hv/iy04NyLBxAdO9njL0iVPN1S4d/A3NVv1V36o8= +github.com/golang/mock v1.4.4 h1:l75CXGRSwbaYNpl/Z2X1XIIAMSCquvXgpVZDhwEIJsc= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= +github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kris-nova/logger v0.0.0-20181127235838-fd0d87064b06 h1:vN4d3jSss3ExzUn2cE0WctxztfOgiKvMKnDrydBsg00= +github.com/kris-nova/logger v0.0.0-20181127235838-fd0d87064b06/go.mod h1:++9BgZujZd4v0ZTZCb5iPsaomXdZWyxotIAh1IiDm44= +github.com/kris-nova/lolgopher v0.0.0-20180124180951-14d43f83481a h1:S6E3FfRMSl737iM/pTvssT/w1BqYFnXFEmdMSTLSxIc= +github.com/kris-nova/lolgopher v0.0.0-20180124180951-14d43f83481a/go.mod h1:V0HF/ZBlN86HqewcDC/cVxMmYDiRukWjSrgKLUAn9Js= +github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8= +github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y= +github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/neurosnap/sentences v1.0.6 h1:iBVUivNtlwGkYsJblWV8GGVFmXzZzak907Ci8aA0VTE= +github.com/neurosnap/sentences v1.0.6/go.mod h1:pg1IapvYpWCJJm/Etxeh0+gtMf1rI1STY9S7eUCPbDc= +github.com/olekukonko/tablewriter v0.0.1 h1:b3iUnf1v+ppJiOfNX4yxxqfWKMQPZR5yoh8urCTFX88= +github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= +github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= +github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= +github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cobra v0.0.5 h1:f0B+LkLX6DtmRH1isoNA9VTtNUK9K8xYd28JNNfOv/s= +github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= +github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= +github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg= +github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= +github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= +golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20201021035429-f5854403a974 h1:IX6qOQeG5uLjB/hjjwjedwfjND0hgjPMMyO1RoIXQNI= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c h1:VwygUrnw9jn88c4u8GD3rZQbqrP/tgas88tPUbBxQrk= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/neurosnap/sentences.v1 v1.0.6 h1:v7ElyP020iEZQONyLld3fHILHWOPs+ntzuQTNPkul8E= +gopkg.in/neurosnap/sentences.v1 v1.0.6/go.mod h1:YlK+SN+fLQZj+kY3r8DkGDhDr91+S3JmTb5LSxFRQo0= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/logo.png b/logo.png new file mode 100644 index 0000000..03bcd2e Binary files /dev/null and b/logo.png differ diff --git a/main.go b/main.go new file mode 100644 index 0000000..665d598 --- /dev/null +++ b/main.go @@ -0,0 +1,7 @@ +package main + +import "github.com/Optum/cloudig/cmd" + +func main() { + cmd.Execute() +} diff --git a/pkg/aws/athena.go b/pkg/aws/athena.go new file mode 100644 index 0000000..6ded04f --- /dev/null +++ b/pkg/aws/athena.go @@ -0,0 +1,435 @@ +package aws + +import ( + "bytes" + "context" + "errors" + "fmt" + "reflect" + "strings" + "text/template" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/service/athena" + "github.com/dchest/uniuri" +) + +// AthenaSVC is a wrapper for Athena service API calls +type AthenaSVC interface { + GetTableforMetadata(*athena.TableMetadata) (*string, error) + CreateTableFromMetadata(*athena.TableMetadata) (*string, error) + RunQuery(tableName, query string) (*athena.ResultSet, error) + GetTableMetadata(string) (*athena.TableMetadata, error) +} + +const ( + createTableTimeout time.Duration = 30 // in seconds + runQueryTimeout time.Duration = 900 // in seconds + readTimeout time.Duration = 10 // in seconds + iterationSleepTime time.Duration = 5 // in seconds + defaultDatabase string = "default" + defaultCatalog string = "AwsDataCatalog" +) + +// NewAthenaTableMetaDataForCloudTrail creates the metadata for CloudTrail table +// Returned metadata will not have Name for the table or location of the datasource +// Note : Sorted by value of Name +func NewAthenaTableMetaDataForCloudTrail(location string, regionList []string) *athena.TableMetadata { + cloudTrailAthenaTableColumns := []*athena.Column{ + { + Name: aws.String("additionaleventdata"), + Type: aws.String("string"), + }, + { + Name: aws.String("apiversion"), + Type: aws.String("string"), + }, + { + Name: aws.String("awsregion"), + Type: aws.String("string"), + }, + { + Name: aws.String("errorcode"), + Type: aws.String("string"), + }, + { + Name: aws.String("errormessage"), + Type: aws.String("string"), + }, + { + Name: aws.String("eventid"), + Type: aws.String("string"), + }, + { + Name: aws.String("eventname"), + Type: aws.String("string"), + }, + { + Name: aws.String("eventsource"), + Type: aws.String("string"), + }, + { + Name: aws.String("eventtime"), + Type: aws.String("string"), + }, + { + Name: aws.String("eventtype"), + Type: aws.String("string"), + }, + { + Name: aws.String("eventversion"), + Type: aws.String("string"), + }, + { + Name: aws.String("readonly"), + Type: aws.String("string"), + }, + { + Name: aws.String("recipientaccountid"), + Type: aws.String("string"), + }, + { + Name: aws.String("requestid"), + Type: aws.String("string"), + }, + { + Name: aws.String("requestparameters"), + Type: aws.String("string"), + }, + { + Name: aws.String("resources"), + Type: aws.String("array>"), + }, + { + Name: aws.String("responseelements"), + Type: aws.String("string"), + }, + { + Name: aws.String("serviceeventdetails"), + Type: aws.String("string"), + }, + { + Name: aws.String("sharedeventid"), + Type: aws.String("string"), + }, + { + Name: aws.String("sourceipaddress"), + Type: aws.String("string"), + }, + { + Name: aws.String("useragent"), + Type: aws.String("string"), + }, + { + Name: aws.String("useridentity"), + Type: aws.String("struct,sessionissuer:struct>>"), + }, + { + Name: aws.String("vpcendpointid"), + Type: aws.String("string"), + }, + } + + // Note : Sorted by value of Name + // TODO : customizable partitions + cloudTrailAthenaTablePartitions := []*athena.Column{ + { + Name: aws.String("day"), + Type: aws.String("string"), + }, + { + Name: aws.String("month"), + Type: aws.String("string"), + }, + { + Name: aws.String("region"), + Type: aws.String("string"), + }, + { + Name: aws.String("year"), + Type: aws.String("string"), + }, + } + + cloudTrailAthenaTableParameters := map[string]*string{ + "serde.serialization.lib": aws.String("com.amazon.emr.hive.serde.CloudTrailSerde"), + "inputformat": aws.String("com.amazon.emr.cloudtrail.CloudTrailInputFormat"), + "outputformat": aws.String("org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"), + "location": aws.String(location), + "projection.enabled": aws.String("true"), // TODO : customizable partition projections + "projection.region.type": aws.String("enum"), + "projection.region.values": aws.String(strings.Join(regionList, ",")), + "projection.year.type": aws.String("integer"), + "projection.year.range": aws.String("2005,2099"), + "projection.month.type": aws.String("integer"), + "projection.month.range": aws.String("1,12"), + "projection.month.digits": aws.String("2"), + "projection.day.type": aws.String("integer"), + "projection.day.range": aws.String("1,31"), + "projection.day.digits": aws.String("2"), + "storage.location.template": aws.String(location + "/${region}/${year}/${month}/${day}"), + } + + return &athena.TableMetadata{ + Columns: cloudTrailAthenaTableColumns, + PartitionKeys: cloudTrailAthenaTablePartitions, + Parameters: cloudTrailAthenaTableParameters, + TableType: aws.String("EXTERNAL_TABLE"), + } +} + +// represents the dataset used to form a query to create table +type tableCreateData struct { + TableName string + Columns map[string]string + Partitions map[string]string + Parameters map[string]string + PartitionProjectionParameters map[string]string +} + +// getDataToCreateTable helper function that creates the struct from the given Athena table metadata +// this struct is used by the template engine to generate the query +func getDataToCreateTable(meta *athena.TableMetadata) *tableCreateData { + columns := make(map[string]string) + for _, v := range meta.Columns { + columns[aws.StringValue(v.Name)] = aws.StringValue(v.Type) + } + partitions := make(map[string]string) + for _, v := range meta.PartitionKeys { + partitions[aws.StringValue(v.Name)] = aws.StringValue(v.Type) + } + + parameters := make(map[string]string) + partitionParameters := make(map[string]string) + for k, v := range meta.Parameters { + if strings.HasPrefix(k, "projection.") || strings.HasPrefix(k, "storage.location.template") { + partitionParameters[k] = aws.StringValue(v) + } else { + parameters[k] = aws.StringValue(v) + } + } + + tableName := defaultDatabase + "." + "reflect_cloudTrail_" + uniuri.NewLen(5) + + return &tableCreateData{ + TableName: tableName, + Columns: columns, + Partitions: partitions, + Parameters: parameters, + PartitionProjectionParameters: partitionParameters, + } +} + +// GetTableforMetadata returns a Athena table in the form . for given metadata and +// an error if there is any. Region is derived from authenticated session +func (client *Client) GetTableforMetadata(meta *athena.TableMetadata) (*string, error) { + resultCatalogs, err := client.Athena.ListDataCatalogs(&athena.ListDataCatalogsInput{}) + if err != nil { + return nil, err + } + if len(resultCatalogs.DataCatalogsSummary) > 0 { + for _, catalogSummary := range resultCatalogs.DataCatalogsSummary { + resultDatabases, err := client.Athena.ListDatabases(&athena.ListDatabasesInput{ + CatalogName: catalogSummary.CatalogName, + }) + if err != nil { + return nil, err + } + if len(resultDatabases.DatabaseList) > 0 { + for _, database := range resultDatabases.DatabaseList { + resultTable, err := client.Athena.ListTableMetadata( + &athena.ListTableMetadataInput{ + CatalogName: catalogSummary.CatalogName, + DatabaseName: database.Name, + }) + if err != nil { + return nil, err + } + if len(resultTable.TableMetadataList) > 0 { + for _, tableMeta := range resultTable.TableMetadataList { + // check "location" key is present before accessing it + if val, ok := tableMeta.Parameters["location"]; ok { + // lets first find the table by comparing the location parameter + if aws.StringValue(val) == aws.StringValue(meta.Parameters["location"]) { + + // compare partition key matches + if !reflect.DeepEqual(meta.PartitionKeys, tableMeta.PartitionKeys) { + continue + } + // compare Columns matches + if !reflect.DeepEqual(meta.Columns, tableMeta.Columns) { + continue + } + + // compare all other parameters matches + totalParams := len(meta.Parameters) + checkedParams := 0 + for pk, pv := range meta.Parameters { + if val, ok := tableMeta.Parameters[pk]; ok { + if aws.StringValue(val) != aws.StringValue(pv) { + break + } + } else { + break + } + checkedParams++ + } + if checkedParams == totalParams { + return aws.String(aws.StringValue(database.Name) + "." + aws.StringValue(tableMeta.Name)), nil + } + } + } + } + } + } + } + } + } + return nil, nil +} + +// CreateTableFromMetadata creates a Athena Table for given metadata and returns a table name in the form . +// and an error if there is any. Region is derived from authenticated session +func (client *Client) CreateTableFromMetadata(meta *athena.TableMetadata) (*string, error) { + queryData := getDataToCreateTable(meta) + /* + CREATE [EXTERNAL] TABLE [IF NOT EXISTS] + [db_name.]table_name [(col_name data_type [COMMENT col_comment] [, ...] )] + [COMMENT table_comment] + [PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)] + [ROW FORMAT row_format] + [STORED AS file_format] + [WITH SERDEPROPERTIES (...)] ] + [LOCATION 's3://bucket_name/[folder]/'] + [TBLPROPERTIES ( ['has_encrypted_data'='true | false',] ['classification'='aws_glue_classification',] property_name=property_value [, ...] ) ] + */ + queryString := ` + CREATE EXTERNAL TABLE {{.TableName}} ({{$first := true}}{{range $key, $value := .Columns}}{{if $first}} {{$first = false}}{{else}},{{end}} + {{$key}} {{$value}}{{end}} + ) + PARTITIONED BY ( {{$first := true}}{{range $key, $value := .Partitions}}{{if $first}} {{$first = false}}{{else}},{{end}} + {{$key}} {{$value}}{{end}} + ) + ROW FORMAT SERDE '{{index .Parameters "serde.serialization.lib"}}' + STORED AS INPUTFORMAT '{{index .Parameters "inputformat"}}' + OUTPUTFORMAT '{{index .Parameters "outputformat"}}' + LOCATION '{{index .Parameters "location"}}' + TBLPROPERTIES({{$first := true}}{{range $key, $value := .PartitionProjectionParameters}}{{if $first}} {{$first = false}}{{else}},{{end}} + "{{$key}}" = "{{$value}}"{{end}} + ) + ` + t := template.Must(template.New("query").Parse(queryString)) + var tpl bytes.Buffer + err := t.Execute(&tpl, queryData) + if err != nil { + return nil, err + } + _, err = client.runQueryToCompletion(meta, tpl.String(), createTableTimeout) + if err != nil { + return nil, err + } + return &queryData.TableName, nil +} + +// RunQuery run the give query on the given table and returns the data and an error if there is any +func (client *Client) RunQuery(tableName, query string) (*athena.ResultSet, error) { + meta, err := client.GetTableMetadata(tableName) + if err != nil { + return nil, err + } + + id, err := client.runQueryToCompletion(meta, query, runQueryTimeout) + if err != nil { + return nil, err + } + ctx := context.Background() + queryOutput, err := client.Athena.GetQueryResultsWithContext( + ctx, + &athena.GetQueryResultsInput{QueryExecutionId: id}, + request.WithResponseReadTimeout(readTimeout*time.Second), + ) + if err != nil { + return nil, err + } + resultSSMeta := queryOutput.ResultSet.ResultSetMetadata + resultSSRows := queryOutput.ResultSet.Rows + token := queryOutput.NextToken + for token != nil { + queryOutput, err := client.Athena.GetQueryResultsWithContext( + ctx, + &athena.GetQueryResultsInput{ + QueryExecutionId: id, + NextToken: token, + }, request.WithResponseReadTimeout(readTimeout*time.Second), + ) + if err != nil { + return nil, err + } + resultSSRows = append(resultSSRows, queryOutput.ResultSet.Rows...) + token = queryOutput.NextToken + } + return &athena.ResultSet{ResultSetMetadata: resultSSMeta, Rows: resultSSRows}, nil +} + +// runQueryToCompletion run the given query on the table derived from the metadata and returns a QueryExecutionId +// when the query is successful within the given timeout(in sec) and an error if the query is not successful +func (client *Client) runQueryToCompletion(meta *athena.TableMetadata, query string, timeout time.Duration) (*string, error) { + input := &athena.StartQueryExecutionInput{ + QueryExecutionContext: &athena.QueryExecutionContext{ + Catalog: aws.String(defaultCatalog), + Database: aws.String(defaultDatabase), + }, + ResultConfiguration: &athena.ResultConfiguration{ + // results are saved in the same bucket where the datasource is + OutputLocation: aws.String(aws.StringValue(meta.Parameters["location"]) + "/athenaQueryResults/"), + }, + QueryString: aws.String(query), + } + ctx := context.Background() + resp, err := client.Athena.StartQueryExecutionWithContext(ctx, input, request.WithResponseReadTimeout(readTimeout*time.Second)) + if err != nil { + return nil, err + } + retryLimit := 1 + limit := int(timeout / iterationSleepTime) + if limit > 0 { + retryLimit = limit + } + for i := 0; i < retryLimit; i++ { + result, err := client.Athena.GetQueryExecution(&athena.GetQueryExecutionInput{QueryExecutionId: resp.QueryExecutionId}) + if err != nil { + return nil, err + } + status := aws.StringValue(result.QueryExecution.Status.State) + if status == athena.QueryExecutionStateSucceeded { + return resp.QueryExecutionId, nil + } + + if status == athena.QueryExecutionStateFailed || status == athena.QueryExecutionStateCancelled { + return nil, fmt.Errorf("Error while running the query. Reason: %s", aws.StringValue(result.QueryExecution.Status.StateChangeReason)) + } + + time.Sleep(iterationSleepTime * time.Second) + } + + // control reaches here only if table creation status is not successful before the Timeout + _, _ = client.Athena.StopQueryExecution(&athena.StopQueryExecutionInput{QueryExecutionId: resp.QueryExecutionId}) + return nil, errors.New("timeout while running the query") +} + +// GetTableMetadata is helper function to return the athena table metadata for given table +func (client *Client) GetTableMetadata(tableName string) (*athena.TableMetadata, error) { + table := strings.Split(tableName, ".") + input := &athena.GetTableMetadataInput{ + CatalogName: aws.String(defaultCatalog), + DatabaseName: aws.String(table[0]), + TableName: aws.String(table[1]), + } + result, err := client.Athena.GetTableMetadata(input) + if err != nil { + return nil, err + } + return result.TableMetadata, nil +} diff --git a/pkg/aws/athena_test.go b/pkg/aws/athena_test.go new file mode 100644 index 0000000..cc02b8e --- /dev/null +++ b/pkg/aws/athena_test.go @@ -0,0 +1,898 @@ +package aws + +import ( + "context" + "errors" + "os" + "reflect" + "regexp" + "strings" + "testing" + "time" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/endpoints" + "github.com/aws/aws-sdk-go/service/athena" + "github.com/golang/mock/gomock" +) + +var ( + regionList []string +) + +func TestMain(m *testing.M) { + for _, p := range endpoints.DefaultPartitions() { + for region := range p.Regions() { + regionList = append(regionList, region) + } + } + + exitCode := m.Run() + os.Exit(exitCode) +} + +func TestClient_GetTableforMetadata(t *testing.T) { + // sess, _ := NewAuthenticatedSession("us-east-1") + // meta := NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail") + // tableName, err := NewClient(sess).GetTableforMetadata(meta) + // if err != nil { + // log.Println(err) + // } + // log.Println(aws.StringValue(tableName)) + // t.Fail() + type args struct { + meta *athena.TableMetadata + } + + tests := []struct { + name string + args args + mockedListDataCatalogsResponse *athena.ListDataCatalogsOutput + mockedListDatabasesResponse *athena.ListDatabasesOutput + mockedListTableMetadataResponse *athena.ListTableMetadataOutput + mockedListTableMetadataErr error + want *string + wantErr bool + }{ + { + name: "getTablesuccessful#1", + args: args{NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList)}, + mockedListDataCatalogsResponse: &athena.ListDataCatalogsOutput{DataCatalogsSummary: []*athena.DataCatalogSummary{ + {CatalogName: aws.String("AwsDataCatalog"), Type: aws.String("GLUE")}, + }}, + mockedListDatabasesResponse: &athena.ListDatabasesOutput{DatabaseList: []*athena.Database{ + {Name: aws.String("default")}, + {Name: aws.String("testDB")}, + {Name: aws.String("simpleDB")}, + }}, + mockedListTableMetadataResponse: &athena.ListTableMetadataOutput{TableMetadataList: []*athena.TableMetadata{ + { + Name: aws.String("reflect_test"), + Columns: []*athena.Column{ + { + Name: aws.String("additionaleventdata"), + Type: aws.String("string"), + }, { + Name: aws.String("apiversion"), + Type: aws.String("string"), + }, { + Name: aws.String("awsregion"), + Type: aws.String("string"), + }, { + Name: aws.String("errorcode"), + Type: aws.String("string"), + }, { + Name: aws.String("errormessage"), + Type: aws.String("string"), + }, { + Name: aws.String("eventid"), + Type: aws.String("string"), + }, { + Name: aws.String("eventname"), + Type: aws.String("string"), + }, { + Name: aws.String("eventsource"), + Type: aws.String("string"), + }, { + Name: aws.String("eventtime"), + Type: aws.String("string"), + }, { + Name: aws.String("eventtype"), + Type: aws.String("string"), + }, { + Name: aws.String("eventversion"), + Type: aws.String("string"), + }, { + Name: aws.String("readonly"), + Type: aws.String("string"), + }, { + Name: aws.String("recipientaccountid"), + Type: aws.String("string"), + }, { + Name: aws.String("requestid"), + Type: aws.String("string"), + }, { + Name: aws.String("requestparameters"), + Type: aws.String("string"), + }, { + Name: aws.String("resources"), + Type: aws.String("array>"), + }, { + Name: aws.String("responseelements"), + Type: aws.String("string"), + }, { + Name: aws.String("serviceeventdetails"), + Type: aws.String("string"), + }, { + Name: aws.String("sharedeventid"), + Type: aws.String("string"), + }, { + Name: aws.String("sourceipaddress"), + Type: aws.String("string"), + }, { + Name: aws.String("useragent"), + Type: aws.String("string"), + }, { + Name: aws.String("useridentity"), + Type: aws.String("struct,sessionissuer:struct>>"), + }, { + Name: aws.String("vpcendpointid"), + Type: aws.String("string"), + }, + }, + Parameters: map[string]*string{ + "serde.serialization.lib": aws.String("com.amazon.emr.hive.serde.CloudTrailSerde"), + "inputformat": aws.String("com.amazon.emr.cloudtrail.CloudTrailInputFormat"), + "outputformat": aws.String("org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"), + "location": aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + "projection.enabled": aws.String("true"), + "projection.region.type": aws.String("enum"), + "projection.region.values": aws.String(strings.Join(regionList, ",")), + "projection.year.type": aws.String("integer"), + "projection.year.range": aws.String("2005,2099"), + "projection.month.type": aws.String("integer"), + "projection.month.range": aws.String("1,12"), + "projection.month.digits": aws.String("2"), + "projection.day.type": aws.String("integer"), + "projection.day.range": aws.String("1,31"), + "projection.day.digits": aws.String("2"), + "storage.location.template": aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail" + "/${region}/${year}/${month}/${day}"), + }, + PartitionKeys: []*athena.Column{ + { + Name: aws.String("day"), + Type: aws.String("string"), + }, + { + Name: aws.String("month"), + Type: aws.String("string"), + }, + { + Name: aws.String("region"), + Type: aws.String("string"), + }, + { + Name: aws.String("year"), + Type: aws.String("string"), + }, + }, + }, + }}, + want: aws.String("default.reflect_test"), + wantErr: false, + }, + { + name: "missingColumns#2", + args: args{NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList)}, + mockedListDataCatalogsResponse: &athena.ListDataCatalogsOutput{DataCatalogsSummary: []*athena.DataCatalogSummary{ + {CatalogName: aws.String("AwsDataCatalog"), Type: aws.String("GLUE")}, + }}, + mockedListDatabasesResponse: &athena.ListDatabasesOutput{DatabaseList: []*athena.Database{ + {Name: aws.String("default")}, + }}, + mockedListTableMetadataResponse: &athena.ListTableMetadataOutput{TableMetadataList: []*athena.TableMetadata{ + { + Name: aws.String("reflect_table"), + Columns: []*athena.Column{ + { + Name: aws.String("readonly"), + Type: aws.String("string"), + }, { + Name: aws.String("recipientaccountid"), + Type: aws.String("string"), + }, { + Name: aws.String("requestid"), + Type: aws.String("string"), + }, { + Name: aws.String("requestparameters"), + Type: aws.String("string"), + }, { + Name: aws.String("resources"), + Type: aws.String("array>"), + }, { + Name: aws.String("responseelements"), + Type: aws.String("string"), + }, { + Name: aws.String("serviceeventdetails"), + Type: aws.String("string"), + }, { + Name: aws.String("sharedeventid"), + Type: aws.String("string"), + }, { + Name: aws.String("sourceipaddress"), + Type: aws.String("string"), + }, { + Name: aws.String("useragent"), + Type: aws.String("string"), + }, { + Name: aws.String("useridentity"), + Type: aws.String("struct,sessionissuer:struct>>"), + }, { + Name: aws.String("vpcendpointid"), + Type: aws.String("string"), + }, + }, + Parameters: map[string]*string{ + "serde.serialization.lib": aws.String("com.amazon.emr.hive.serde.CloudTrailSerde"), + "inputformat": aws.String("com.amazon.emr.cloudtrail.CloudTrailInputFormat"), + "outputformat": aws.String("org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"), + "location": aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + "projection.enabled": aws.String("true"), + "projection.region.type": aws.String("enum"), + "projection.region.values": aws.String("us-east-1,us-east-2,us-west-1,us-west-2"), + "projection.year.type": aws.String("integer"), + "projection.year.range": aws.String("2005,2099"), + "projection.month.type": aws.String("integer"), + "projection.month.range": aws.String("1,12"), + "projection.month.digits": aws.String("2"), + "projection.day.type": aws.String("integer"), + "projection.day.range": aws.String("1,31"), + "projection.day.digits": aws.String("2"), + "storage.location.template": aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail" + "/${region}/${year}/${month}/${day}"), + }, + PartitionKeys: []*athena.Column{ + { + Name: aws.String("day"), + Type: aws.String("string"), + }, + { + Name: aws.String("month"), + Type: aws.String("string"), + }, + { + Name: aws.String("region"), + Type: aws.String("string"), + }, + { + Name: aws.String("year"), + Type: aws.String("string"), + }, + }, + }, + }}, + want: nil, + wantErr: false, + }, + { + name: "missingParameters#3", + args: args{NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList)}, + mockedListDataCatalogsResponse: &athena.ListDataCatalogsOutput{DataCatalogsSummary: []*athena.DataCatalogSummary{ + {CatalogName: aws.String("AwsDataCatalog"), Type: aws.String("GLUE")}, + }}, + mockedListDatabasesResponse: &athena.ListDatabasesOutput{DatabaseList: []*athena.Database{ + {Name: aws.String("default")}, + {Name: aws.String("testDB")}, + {Name: aws.String("simpleDB")}, + }}, + mockedListTableMetadataResponse: &athena.ListTableMetadataOutput{TableMetadataList: []*athena.TableMetadata{ + { + Name: aws.String("reflect_test"), + Columns: []*athena.Column{ + { + Name: aws.String("additionaleventdata"), + Type: aws.String("string"), + }, { + Name: aws.String("apiversion"), + Type: aws.String("string"), + }, { + Name: aws.String("awsregion"), + Type: aws.String("string"), + }, { + Name: aws.String("errorcode"), + Type: aws.String("string"), + }, { + Name: aws.String("errormessage"), + Type: aws.String("string"), + }, { + Name: aws.String("eventid"), + Type: aws.String("string"), + }, { + Name: aws.String("eventname"), + Type: aws.String("string"), + }, { + Name: aws.String("eventsource"), + Type: aws.String("string"), + }, { + Name: aws.String("eventtime"), + Type: aws.String("string"), + }, { + Name: aws.String("eventtype"), + Type: aws.String("string"), + }, { + Name: aws.String("eventversion"), + Type: aws.String("string"), + }, { + Name: aws.String("readonly"), + Type: aws.String("string"), + }, { + Name: aws.String("recipientaccountid"), + Type: aws.String("string"), + }, { + Name: aws.String("requestid"), + Type: aws.String("string"), + }, { + Name: aws.String("requestparameters"), + Type: aws.String("string"), + }, { + Name: aws.String("resources"), + Type: aws.String("array>"), + }, { + Name: aws.String("responseelements"), + Type: aws.String("string"), + }, { + Name: aws.String("serviceeventdetails"), + Type: aws.String("string"), + }, { + Name: aws.String("sharedeventid"), + Type: aws.String("string"), + }, { + Name: aws.String("sourceipaddress"), + Type: aws.String("string"), + }, { + Name: aws.String("useragent"), + Type: aws.String("string"), + }, { + Name: aws.String("useridentity"), + Type: aws.String("struct,sessionissuer:struct>>"), + }, { + Name: aws.String("vpcendpointid"), + Type: aws.String("string"), + }, + }, + Parameters: map[string]*string{ + "serde.serialization.lib": aws.String("com.amazon.emr.hive.serde.CloudTrailSerde"), + "inputformat": aws.String("com.amazon.emr.cloudtrail.CloudTrailInputFormat"), + "outputformat": aws.String("org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"), + "location": aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + "projection.enabled": aws.String("true"), + "projection.region.type": aws.String("enum"), + "projection.month.digits": aws.String("2"), + "projection.day.type": aws.String("integer"), + "projection.day.range": aws.String("1,31"), + "projection.day.digits": aws.String("2"), + "storage.location.template": aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail" + "/${region}/${year}/${month}/${day}"), + }, + PartitionKeys: []*athena.Column{ + { + Name: aws.String("day"), + Type: aws.String("string"), + }, + { + Name: aws.String("month"), + Type: aws.String("string"), + }, + { + Name: aws.String("region"), + Type: aws.String("string"), + }, + { + Name: aws.String("year"), + Type: aws.String("string"), + }, + }, + }, + }}, + want: nil, + wantErr: false, + }, + { + name: "errorFromListTableMetData#4", + args: args{NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList)}, + mockedListDataCatalogsResponse: &athena.ListDataCatalogsOutput{DataCatalogsSummary: []*athena.DataCatalogSummary{ + {CatalogName: aws.String("AwsDataCatalog"), Type: aws.String("GLUE")}, + }}, + mockedListDatabasesResponse: &athena.ListDatabasesOutput{DatabaseList: []*athena.Database{ + {Name: aws.String("default")}, + {Name: aws.String("testDB")}, + {Name: aws.String("simpleDB")}, + }}, + mockedListTableMetadataResponse: &athena.ListTableMetadataOutput{}, + mockedListTableMetadataErr: errors.New("some error"), + want: nil, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockAthenaAPI := mocks.NewMockAthenaAPI(mockCtrl) + mockAthenaAPI.EXPECT().ListDataCatalogs(&athena.ListDataCatalogsInput{}).Return(tt.mockedListDataCatalogsResponse, nil) + for _, v := range tt.mockedListDataCatalogsResponse.DataCatalogsSummary { + mockAthenaAPI.EXPECT().ListDatabases(&athena.ListDatabasesInput{CatalogName: v.CatalogName}).Return(tt.mockedListDatabasesResponse, nil).AnyTimes() + for _, v1 := range tt.mockedListDatabasesResponse.DatabaseList { + mockAthenaAPI.EXPECT().ListTableMetadata(&athena.ListTableMetadataInput{CatalogName: v.CatalogName, DatabaseName: v1.Name}).Return(tt.mockedListTableMetadataResponse, tt.mockedListTableMetadataErr).AnyTimes() + } + } + client := &Client{ + Athena: mockAthenaAPI, + } + got, err := client.GetTableforMetadata(tt.args.meta) + if (err != nil) != tt.wantErr { + t.Errorf("Client.GetTableforMetadata() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got == nil { + if tt.want != nil { + t.Errorf("Client.GetTableforMetadata() = %v, want %v", got, tt.want) + } + } else if *got != *tt.want { + t.Errorf("Client.GetTableforMetadata() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestClient_CreateTableFromMetadata(t *testing.T) { + // sess, _ := NewAuthenticatedSession("us-east-1") + // meta := NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail") + // tableName, err := NewClient(sess).CreateTableFromMetadata(meta) + // if err != nil { + // log.Println(err) + // } + // log.Println(aws.StringValue(tableName)) + // t.Fail() + meta := NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList) + metaBadLocation := NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList). + SetParameters(map[string]*string{}). + SetPartitionKeys([]*athena.Column{}) + somePointerToString := aws.String("testmenomore") + type args struct { + meta *athena.TableMetadata + } + tests := []struct { + name string + args args + mockedStartQueryExecutionWithContextResponse *athena.StartQueryExecutionOutput + mockedGetQueryExecutionResponse *athena.GetQueryExecutionOutput + match bool + wantErr bool + }{ + { + name: "createTableSuccess#1", + args: args{meta: meta}, + mockedStartQueryExecutionWithContextResponse: &athena.StartQueryExecutionOutput{ + QueryExecutionId: somePointerToString, + }, + mockedGetQueryExecutionResponse: &athena.GetQueryExecutionOutput{ + QueryExecution: &athena.QueryExecution{ + Status: &athena.QueryExecutionStatus{State: aws.String(athena.QueryExecutionStateSucceeded)}, + }, + }, + match: true, + wantErr: false, + }, + { + name: "badQueryData#2", + args: args{meta: metaBadLocation}, + mockedStartQueryExecutionWithContextResponse: &athena.StartQueryExecutionOutput{ + QueryExecutionId: somePointerToString, + }, + mockedGetQueryExecutionResponse: &athena.GetQueryExecutionOutput{ + QueryExecution: &athena.QueryExecution{ + Status: &athena.QueryExecutionStatus{State: aws.String(athena.QueryExecutionStateFailed)}, + }, + }, + match: false, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockAthenaAPI := mocks.NewMockAthenaAPI(mockCtrl) + // https://github.com/golang/mock/issues/324 + mockAthenaAPI.EXPECT().StartQueryExecutionWithContext(context.Background(), gomock.Any(), gomock.Any()).Return(tt.mockedStartQueryExecutionWithContextResponse, nil) + mockAthenaAPI.EXPECT().GetQueryExecution(&athena.GetQueryExecutionInput{ + QueryExecutionId: tt.mockedStartQueryExecutionWithContextResponse.QueryExecutionId, + }).Return(tt.mockedGetQueryExecutionResponse, nil).AnyTimes() + client := &Client{ + Athena: mockAthenaAPI, + } + got, err := client.CreateTableFromMetadata(tt.args.meta) + if (err != nil) != tt.wantErr { + t.Errorf("Client.CreateTableFromMetadata() error = %v, wantErr %v", err, tt.wantErr) + return + } + regexMatch, _ := regexp.MatchString("default.reflect_cloudTrail_[A-Za-z0-9]{5}$", aws.StringValue(got)) + if tt.match != regexMatch { + t.Errorf("Client.CreateTableFromMetadata() got = %v, doesn't match '%v'", aws.StringValue(got), "default.reflect_cloudTrail_[A-Za-z0-9]{5}$") + } + }) + } +} + +func TestClient_RunQuery(t *testing.T) { + // sess, _ := NewAuthenticatedSession("us-east-1") + // query1 := + // `SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode,count(useridentity.sessioncontext.sessionissuer.arn) AS count + // FROM default.reflect_cloudtrail_gxev4 + // WHERE region='us-east-1' + // AND year IN ('2020') + // AND month IN ('11') + // AND day IN ('14','15','16','17','18','19','20','21') + // AND eventtime >= '2020-11-14T00:00:00Z' + // AND eventtime <= '2020-11-21T23:59:59Z' + // AND useridentity.arn != '' + // AND (errorcode LIKE '%UnauthorizedOperation' OR errorcode LIKE 'AccessDenied%') + // GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode + // ORDER BY useridentity.arn,count DESC` + + // result, err := NewClient(sess).RunQuery("default.reflect_cloudtrail_gxev4", query1) + // if err != nil { + // log.Println(err) + // t.Fail() + // } + // //log.Println(result.ResultSetMetadata.ColumnInfo) + // // data := make(map[string]string) + // // dataSet := make([]map[string]string, 0) + // // keys := make([]string, 0) + // // //values := make([]string, 0) + // // for k, v := range result.Rows { + // // if k == 0 { + // // for _, v1 := range v.Data { + // // keys = append(keys, aws.StringValue(v1.VarCharValue)) + // // } + // // continue + // // } + // // for k2, v2 := range v.Data { + // // data[keys[k2]] = aws.StringValue(v2.VarCharValue) + // // } + // // dataSet = append(dataSet, data) + // // //log.Println(v.GoString()) + // // } + // // log.Println(dataSet) + // table := tablewriter.NewWriter(os.Stdout) + // table.SetRowLine(true) + // table.SetRowSeparator("-") + // keys := make([]string, 0) + // values := make([]string, 0) + // for k, v := range result.Rows { + // if k == 0 { + // for _, v1 := range v.Data { + // keys = append(keys, aws.StringValue(v1.VarCharValue)) + // } + // table.SetHeader(keys) + // continue + // } + // for _, v2 := range v.Data { + // values = append(values, aws.StringValue(v2.VarCharValue)) + // } + // table.Append(values) + // values = nil + // } + // table.Render() + // t.Fail() + meta := NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList) + somePointerToString := aws.String("testmenomore") + resultSet := &athena.ResultSet{ + ResultSetMetadata: &athena.ResultSetMetadata{ColumnInfo: []*athena.ColumnInfo{ + { + Name: aws.String("arn"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventsource"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventname"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("errorcode"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("count"), + Type: aws.String("varchar"), + }, + }}, + Rows: []*athena.Row{ + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn")}, + {VarCharValue: aws.String("eventsource")}, + {VarCharValue: aws.String("eventname")}, + {VarCharValue: aws.String("errorcode")}, + {VarCharValue: aws.String("count")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass")}, + {VarCharValue: aws.String("sts.amazonaws.com")}, + {VarCharValue: aws.String("AssumeRole")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("15")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_Read")}, + {VarCharValue: aws.String("iam.amazonaws.com")}, + {VarCharValue: aws.String("UpdateAssumeRolePolicy")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("1")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/configuration-recorder-role")}, + {VarCharValue: aws.String("kms.amazonaws.com")}, + {VarCharValue: aws.String("DescribeKey")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("6")}, + }, + }, + }, + } + + type args struct { + tableName string + query string + } + tests := []struct { + name string + args args + mockedGetTableMetadataResponse *athena.GetTableMetadataOutput + mockedStartQueryExecutionWithContextResponse *athena.StartQueryExecutionOutput + mockedGetQueryExecutionResponse *athena.GetQueryExecutionOutput + mockedGetQueryResultsWithContextResponse *athena.GetQueryResultsOutput + want *athena.ResultSet + wantErr bool + }{ + { + name: "runQuerySuccess#1", + args: args{ + "default.reflect_test", + `SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode,count(useridentity.sessioncontext.sessionissuer.arn) AS count + FROM default.reflect_test + WHERE region='us-east-1' + AND year IN ('2020') + AND month IN ('11') + AND day IN ('14','15','16','17','18','19','20','21') + AND eventtime >= '2020-11-14T00:00:00Z' + AND eventtime <= '2020-11-21T23:59:59Z' + AND useridentity.arn != '' + AND (errorcode LIKE '%UnauthorizedOperation' OR errorcode LIKE 'AccessDenied%') + GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode + ORDER BY useridentity.arn,count DESC`, + }, + mockedGetTableMetadataResponse: &athena.GetTableMetadataOutput{ + TableMetadata: meta, + }, + mockedStartQueryExecutionWithContextResponse: &athena.StartQueryExecutionOutput{ + QueryExecutionId: somePointerToString, + }, + mockedGetQueryExecutionResponse: &athena.GetQueryExecutionOutput{ + QueryExecution: &athena.QueryExecution{ + Status: &athena.QueryExecutionStatus{State: aws.String(athena.QueryExecutionStateSucceeded)}, + }, + }, + mockedGetQueryResultsWithContextResponse: &athena.GetQueryResultsOutput{ResultSet: resultSet}, + want: resultSet, + wantErr: false, + }, + { + name: "QueryFailure#2", + args: args{ + "default.reflect_test", + `SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode,count(useridentity.sessioncontext.sessionissuer.arn) AS count + FROM default.reflect_test + WHERE region='us-east-1' + AND year IN ('2020') + AND month IN ('11') + AND day IN ('14','15','16','17','18','19','20','21') + AND eventtime >= '2020-11-14T00:00:00Z' + AND eventtime <= '2020-11-21T23:59:59Z' + AND useridentity.arn != '' + AND (errorcode LIKE '%UnauthorizedOperation' OR errorcode LIKE 'AccessDenied%') + GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode + ORDER BY useridentity.arn,count DESC`, + }, + mockedGetTableMetadataResponse: &athena.GetTableMetadataOutput{ + TableMetadata: meta, + }, + mockedStartQueryExecutionWithContextResponse: &athena.StartQueryExecutionOutput{ + QueryExecutionId: somePointerToString, + }, + mockedGetQueryExecutionResponse: &athena.GetQueryExecutionOutput{ + QueryExecution: &athena.QueryExecution{ + Status: &athena.QueryExecutionStatus{State: aws.String(athena.QueryExecutionStateFailed)}, + }, + }, + mockedGetQueryResultsWithContextResponse: &athena.GetQueryResultsOutput{ResultSet: nil}, + want: nil, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockAthenaAPI := mocks.NewMockAthenaAPI(mockCtrl) + mockAthenaAPI.EXPECT().GetTableMetadata(gomock.Any()).Return(tt.mockedGetTableMetadataResponse, nil) + mockAthenaAPI.EXPECT().StartQueryExecutionWithContext(context.Background(), gomock.Any(), gomock.Any()).Return(tt.mockedStartQueryExecutionWithContextResponse, nil) + mockAthenaAPI.EXPECT().GetQueryExecution(&athena.GetQueryExecutionInput{ + QueryExecutionId: tt.mockedStartQueryExecutionWithContextResponse.QueryExecutionId, + }).Return(tt.mockedGetQueryExecutionResponse, nil).AnyTimes() + mockAthenaAPI.EXPECT().GetQueryResultsWithContext(context.Background(), &athena.GetQueryResultsInput{ + QueryExecutionId: aws.String("testmenomore"), + }, gomock.Any()).Return(tt.mockedGetQueryResultsWithContextResponse, nil).AnyTimes() + client := &Client{ + Athena: mockAthenaAPI, + } + got, err := client.RunQuery(tt.args.tableName, tt.args.query) + if (err != nil) != tt.wantErr { + t.Errorf("Client.RunQuery() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("Client.RunQuery() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestClient_runQueryToCompletion(t *testing.T) { + somePointerToString := aws.String("testmenomore") + type args struct { + meta *athena.TableMetadata + query string + timeout time.Duration + } + tests := []struct { + name string + args args + mockedStartQueryExecutionWithContextResponse *athena.StartQueryExecutionOutput + mockedGetQueryExecutionResponse *athena.GetQueryExecutionOutput + want *string + wantErr bool + }{ + { + name: "executionStateSucceeded#1", + args: args{ + NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList), + `SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode,count(useridentity.sessioncontext.sessionissuer.arn) AS count + FROM default.reflect_cloudtrail_gxev4 + WHERE region='us-east-1' + AND year IN ('2020') + AND month IN ('11') + AND day IN ('14','15','16','17','18','19','20','21') + AND eventtime >= '2020-11-14T00:00:00Z' + AND eventtime <= '2020-11-21T23:59:59Z' + AND useridentity.arn != '' + AND (errorcode LIKE '%UnauthorizedOperation' OR errorcode LIKE 'AccessDenied%') + GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode + ORDER BY useridentity.arn,count DESC`, + 60, + }, + mockedStartQueryExecutionWithContextResponse: &athena.StartQueryExecutionOutput{ + QueryExecutionId: somePointerToString, + }, + mockedGetQueryExecutionResponse: &athena.GetQueryExecutionOutput{ + QueryExecution: &athena.QueryExecution{ + Status: &athena.QueryExecutionStatus{State: aws.String(athena.QueryExecutionStateSucceeded)}, + }, + }, + want: somePointerToString, + wantErr: false, + }, + { + name: "executionStateFailed#2", + args: args{ + NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList), + `SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode,count(useridentity.sessioncontext.sessionissuer.arn) AS count + FROM default.reflect_cloudtrail_gxev4 + WHERE region='us-east-1' + AND year IN ('2020') + AND month IN ('11') + AND day IN ('14','15','16','17','18','19','20','21') + AND eventtime >= '2020-11-14T00:00:00Z' + AND eventtime <= '2020-11-21T23:59:59Z' + AND useridentity.arn != '' + AND (errorcode LIKE '%UnauthorizedOperation' OR errorcode LIKE 'AccessDenied%') + GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode + ORDER BY useridentity.arn,count DESC`, + 30, + }, + mockedStartQueryExecutionWithContextResponse: &athena.StartQueryExecutionOutput{ + QueryExecutionId: somePointerToString, + }, + mockedGetQueryExecutionResponse: &athena.GetQueryExecutionOutput{ + QueryExecution: &athena.QueryExecution{ + Status: &athena.QueryExecutionStatus{State: aws.String(athena.QueryExecutionStateFailed)}, + }, + }, + want: nil, + wantErr: true, + }, + { + name: "executionTimeout#3", + args: args{ + NewAthenaTableMetaDataForCloudTrail("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail", regionList), + `SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode,count(useridentity.sessioncontext.sessionissuer.arn) AS count + FROM default.reflect_cloudtrail_gxev4 + WHERE region='us-east-1' + AND year IN ('2020') + AND month IN ('11') + AND day IN ('14','15','16','17','18','19','20','21') + AND eventtime >= '2020-11-14T00:00:00Z' + AND eventtime <= '2020-11-21T23:59:59Z' + AND useridentity.arn != '' + AND (errorcode LIKE '%UnauthorizedOperation' OR errorcode LIKE 'AccessDenied%') + GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode + ORDER BY useridentity.arn,count DESC`, + 5, + }, + mockedStartQueryExecutionWithContextResponse: &athena.StartQueryExecutionOutput{ + QueryExecutionId: somePointerToString, + }, + mockedGetQueryExecutionResponse: &athena.GetQueryExecutionOutput{ + QueryExecution: &athena.QueryExecution{ + Status: &athena.QueryExecutionStatus{State: aws.String(athena.QueryExecutionStateRunning)}, + }, + }, + want: nil, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockAthenaAPI := mocks.NewMockAthenaAPI(mockCtrl) + ctx := context.Background() + input := &athena.StartQueryExecutionInput{ + QueryExecutionContext: &athena.QueryExecutionContext{ + Catalog: aws.String(defaultCatalog), + Database: aws.String(defaultDatabase), + }, + ResultConfiguration: &athena.ResultConfiguration{ + OutputLocation: aws.String(aws.StringValue(tt.args.meta.Parameters["location"]) + "/athenaQueryResults/"), + }, + QueryString: aws.String(tt.args.query), + } + // https://github.com/golang/mock/issues/324 + mockAthenaAPI.EXPECT().StartQueryExecutionWithContext(ctx, input, gomock.Any()).Return(tt.mockedStartQueryExecutionWithContextResponse, nil) + mockAthenaAPI.EXPECT().GetQueryExecution(&athena.GetQueryExecutionInput{ + QueryExecutionId: tt.mockedStartQueryExecutionWithContextResponse.QueryExecutionId, + }).Return(tt.mockedGetQueryExecutionResponse, nil).AnyTimes() + mockAthenaAPI.EXPECT().StopQueryExecution(gomock.Any()).Return(&athena.StopQueryExecutionOutput{}, nil).AnyTimes() + client := &Client{ + Athena: mockAthenaAPI, + } + got, err := client.runQueryToCompletion(tt.args.meta, tt.args.query, tt.args.timeout) + if (err != nil) != tt.wantErr { + t.Errorf("Client.runQueryToCompletion() error = %v, wantErr %v", err, tt.wantErr) + return + } + if got != tt.want { + t.Errorf("Client.runQueryToCompletion() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/aws/aws.go b/pkg/aws/aws.go new file mode 100644 index 0000000..3be40d0 --- /dev/null +++ b/pkg/aws/aws.go @@ -0,0 +1,122 @@ +package aws + +import ( + "fmt" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/credentials" + "github.com/aws/aws-sdk-go/aws/credentials/stscreds" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/athena" + "github.com/aws/aws-sdk-go/service/athena/athenaiface" + "github.com/aws/aws-sdk-go/service/cloudtrail" + "github.com/aws/aws-sdk-go/service/cloudtrail/cloudtrailiface" + "github.com/aws/aws-sdk-go/service/configservice" + "github.com/aws/aws-sdk-go/service/ec2" + "github.com/aws/aws-sdk-go/service/ecr" + "github.com/aws/aws-sdk-go/service/ecr/ecriface" + "github.com/aws/aws-sdk-go/service/health" + "github.com/aws/aws-sdk-go/service/iam" + "github.com/aws/aws-sdk-go/service/iam/iamiface" + "github.com/aws/aws-sdk-go/service/inspector" + "github.com/aws/aws-sdk-go/service/sts" + "github.com/aws/aws-sdk-go/service/support" + "github.com/kris-nova/logger" + + "github.com/aws/aws-sdk-go/service/configservice/configserviceiface" + "github.com/aws/aws-sdk-go/service/ec2/ec2iface" + "github.com/aws/aws-sdk-go/service/health/healthiface" + "github.com/aws/aws-sdk-go/service/inspector/inspectoriface" + "github.com/aws/aws-sdk-go/service/sts/stsiface" + "github.com/aws/aws-sdk-go/service/support/supportiface" +) + +// APIs represent the different API calls available to the AWS client +type APIs interface { + EC2SVC + TrustedAdvisorSVC + ConfigServiceSVC + InspectorSVC + STSSVC + IAMSVC + HealthSVC + ECRSVC + CloudTrailSVC + AthenaSVC +} + +// Client is the client for AWS API operations +type Client struct { + EC2 ec2iface.EC2API + TrustedAdvisor supportiface.SupportAPI + AWSConfig configserviceiface.ConfigServiceAPI + Inspector inspectoriface.InspectorAPI + STS stsiface.STSAPI + IAM iamiface.IAMAPI + Health healthiface.HealthAPI + ECR ecriface.ECRAPI + CloudTrail cloudtrailiface.CloudTrailAPI + Athena athenaiface.AthenaAPI +} + +// NewClient creates a Client object that implement all the methods in the APIs interface +func NewClient(sess *session.Session) APIs { + config := constructAWSConfig() + return &Client{ + EC2: ec2.New(sess, config), + TrustedAdvisor: support.New(sess, config), + AWSConfig: configservice.New(sess, config), + Inspector: inspector.New(sess, config), + STS: sts.New(sess, config), + IAM: iam.New(sess, config), + Health: health.New(sess, config), + ECR: ecr.New(sess, config), + CloudTrail: cloudtrail.New(sess, config), + Athena: athena.New(sess, config), + } +} + +// NewClientAsAssumeRole creates a Client object that assumes a role +func NewClientAsAssumeRole(sess *session.Session, roleARN string) APIs { + creds := getRoleCredentials(sess, roleARN) + config := constructAWSConfig().WithCredentials(creds) + return &Client{ + EC2: ec2.New(sess, config), + TrustedAdvisor: support.New(sess, config), + AWSConfig: configservice.New(sess, config), + Inspector: inspector.New(sess, config), + STS: sts.New(sess, config), + IAM: iam.New(sess, config), + Health: health.New(sess, config), + ECR: ecr.New(sess, config), + CloudTrail: cloudtrail.New(sess, config), + Athena: athena.New(sess, config), + } +} + +// NewAuthenticatedSession creates an AWS Session using the credentials from the running environment +func NewAuthenticatedSession(region string) (*session.Session, error) { + sess, err := session.NewSession(aws.NewConfig().WithRegion(region)) + if err != nil { + return nil, err + } + return sess, err +} + +// Function that gets credentials for non-parent accounts +func getRoleCredentials(sess *session.Session, roleARN string) (creds *credentials.Credentials) { + return stscreds.NewCredentials(sess, roleARN) +} + +// constructAWSConfig is helper function to create and return pointer to aws config +func constructAWSConfig() *aws.Config { + config := aws.NewConfig() + if logger.Level >= 5 { + config.WithCredentialsChainVerboseErrors(true). + WithLogLevel(aws.LogDebugWithHTTPBody). + WithLogger(aws.LoggerFunc(func(args ...interface{}) { + logger.Debug(fmt.Sprintln(args...)) + })) + } + return config +} diff --git a/pkg/aws/awsconfig.go b/pkg/aws/awsconfig.go new file mode 100644 index 0000000..bc1ffb4 --- /dev/null +++ b/pkg/aws/awsconfig.go @@ -0,0 +1,59 @@ +package aws + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/configservice" +) + +// ConfigServiceSVC is a wrapper for ConfigService API calls +type ConfigServiceSVC interface { + GetNonComplaintConfigRules() (map[string][]*configservice.EvaluationResult, error) +} + +// GetNonComplaintConfigRules returns all the non complaint rules with compliance results +func (client *Client) GetNonComplaintConfigRules() (map[string][]*configservice.EvaluationResult, error) { + var rulesNextToken *string + var rulesComplianceNextToken *string + results := make(map[string][]*configservice.EvaluationResult) + for { + configRuleOutput, err := client.AWSConfig.DescribeComplianceByConfigRule(&configservice.DescribeComplianceByConfigRuleInput{ + NextToken: rulesNextToken, + }) + if err != nil { + return nil, err + } + + for _, v := range configRuleOutput.ComplianceByConfigRules { + if aws.StringValue(v.Compliance.ComplianceType) != configservice.ComplianceTypeInsufficientData && aws.StringValue(v.Compliance.ComplianceType) != configservice.ComplianceTypeCompliant { + evaluationResults := make([]*configservice.EvaluationResult, 0) + for { + configRuleComplianceOutput, err := client.AWSConfig.GetComplianceDetailsByConfigRule(&configservice.GetComplianceDetailsByConfigRuleInput{ + ConfigRuleName: v.ConfigRuleName, + Limit: aws.Int64(100), + NextToken: rulesComplianceNextToken, + }) + + if err != nil { + return nil, err + } + evaluationResults = append(evaluationResults, configRuleComplianceOutput.EvaluationResults...) + + rulesComplianceNextToken = configRuleComplianceOutput.NextToken + if rulesComplianceNextToken == nil { + break + } + + } + results[aws.StringValue(v.ConfigRuleName)] = evaluationResults + } + + } + rulesNextToken = configRuleOutput.NextToken + if rulesNextToken == nil { + break + } + + } + + return results, nil +} diff --git a/pkg/aws/awsconfig_test.go b/pkg/aws/awsconfig_test.go new file mode 100644 index 0000000..d262192 --- /dev/null +++ b/pkg/aws/awsconfig_test.go @@ -0,0 +1,210 @@ +package aws + +import ( + "errors" + "testing" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/configservice" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" +) + +func TestGetNonComplaintConfigRules(t *testing.T) { + testCases := []struct { + name string + mockedDescribeComplianceByConfigRuleResponse []*configservice.DescribeComplianceByConfigRuleOutput + mockedGetComplianceDetailsByConfigRuleResponse []*configservice.GetComplianceDetailsByConfigRuleOutput + mockedDescribeComplianceByConfigRuleError error + mockedGetComplianceDetailsByConfigRuleError error + expectedOutput map[string][]*configservice.EvaluationResult + expectedError error + }{ + { + name: "Empty response", + mockedDescribeComplianceByConfigRuleResponse: []*configservice.DescribeComplianceByConfigRuleOutput{{}}, + expectedOutput: map[string][]*configservice.EvaluationResult{}, + expectedError: nil, + }, + { + name: "Populated response", + mockedDescribeComplianceByConfigRuleResponse: []*configservice.DescribeComplianceByConfigRuleOutput{ + { + ComplianceByConfigRules: []*configservice.ComplianceByConfigRule{ + { + Compliance: &configservice.Compliance{ + ComplianceType: aws.String("NON_COMPLIANT"), + }, + ConfigRuleName: aws.String("CUSTOM_UNATTACHED_ENCRYPTED_VOLUMES"), + }, + { + Compliance: &configservice.Compliance{ + ComplianceType: aws.String("NON_COMPLIANT"), + }, + ConfigRuleName: aws.String("S3_BUCKET_PUBLIC_WRITE_PROHIBITED"), + }, + }, + NextToken: aws.String("dsfsdfdsfsdf"), + }, + { + ComplianceByConfigRules: []*configservice.ComplianceByConfigRule{ + { + Compliance: &configservice.Compliance{ + ComplianceType: aws.String("COMPLIANT"), + }, + ConfigRuleName: aws.String("S3_BUCKET_OPEN"), + }, + { + Compliance: &configservice.Compliance{ + ComplianceType: aws.String("INSUFFICIENT_DATA"), + }, + ConfigRuleName: aws.String("EC2_SSH_OPEN_TO_INTERNET"), + }, + }, + }, + }, + mockedGetComplianceDetailsByConfigRuleResponse: []*configservice.GetComplianceDetailsByConfigRuleOutput{ + { + EvaluationResults: []*configservice.EvaluationResult{ + { + Annotation: aws.String("Volume is encrypted and attached"), + ComplianceType: aws.String("COMPLIANT"), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("CUSTOM_UNATTACHED_ENCRYPTED_VOLUMES"), + ResourceId: aws.String("vol-0020f9b701caa2314"), + ResourceType: aws.String("AWS::EC2::Volume"), + }, + }, + }, + { + Annotation: aws.String("Volume is encrypted and attached"), + ComplianceType: aws.String("NON_COMPLIANT"), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("CUSTOM_UNATTACHED_ENCRYPTED_VOLUMES"), + ResourceId: aws.String("vol-f0u5n6u3s4e4e5it"), + ResourceType: aws.String("AWS::EC2::Volume"), + }, + }, + }, + }, + }, + { + EvaluationResults: []*configservice.EvaluationResult{ + { + Annotation: aws.String("public write prohibited"), + ComplianceType: aws.String("NON_COMPLIANT"), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("S3_BUCKET_PUBLIC_WRITE_PROHIBITED"), + ResourceId: aws.String("sing-dong-bucket"), + ResourceType: aws.String("AWS::S3::Bucket"), + }, + }, + }, + }, + }, + }, + expectedOutput: map[string][]*configservice.EvaluationResult{ + "CUSTOM_UNATTACHED_ENCRYPTED_VOLUMES": { + { + Annotation: aws.String("Volume is encrypted and attached"), + ComplianceType: aws.String("COMPLIANT"), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("CUSTOM_UNATTACHED_ENCRYPTED_VOLUMES"), + ResourceId: aws.String("vol-0020f9b701caa2314"), + ResourceType: aws.String("AWS::EC2::Volume"), + }, + }, + }, + { + Annotation: aws.String("Volume is encrypted and attached"), + ComplianceType: aws.String("NON_COMPLIANT"), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("CUSTOM_UNATTACHED_ENCRYPTED_VOLUMES"), + ResourceId: aws.String("vol-f0u5n6u3s4e4e5it"), + ResourceType: aws.String("AWS::EC2::Volume"), + }, + }, + }, + }, + "S3_BUCKET_PUBLIC_WRITE_PROHIBITED": { + { + Annotation: aws.String("public write prohibited"), + ComplianceType: aws.String("NON_COMPLIANT"), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("S3_BUCKET_PUBLIC_WRITE_PROHIBITED"), + ResourceId: aws.String("sing-dong-bucket"), + ResourceType: aws.String("AWS::S3::Bucket"), + }, + }, + }, + }, + }, + expectedError: nil, + }, + { + name: "error response from DescribeComplianceByConfigRule", + mockedDescribeComplianceByConfigRuleResponse: nil, + mockedGetComplianceDetailsByConfigRuleResponse: nil, + mockedDescribeComplianceByConfigRuleError: errors.New("some error"), + expectedOutput: nil, + expectedError: errors.New("some error"), + }, + { + name: "error response from GetComplianceDetailsByConfigRule", + mockedDescribeComplianceByConfigRuleResponse: []*configservice.DescribeComplianceByConfigRuleOutput{ + { + ComplianceByConfigRules: []*configservice.ComplianceByConfigRule{ + { + Compliance: &configservice.Compliance{ + ComplianceType: aws.String("NON_COMPLIANT"), + }, + ConfigRuleName: aws.String("CUSTOM_UNATTACHED_ENCRYPTED_VOLUMES"), + }, + }, + }, + }, + mockedGetComplianceDetailsByConfigRuleResponse: nil, + mockedGetComplianceDetailsByConfigRuleError: errors.New("some error"), + expectedOutput: nil, + expectedError: errors.New("some error"), + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockConfigServiceAPI := mocks.NewMockConfigServiceAPI(mockCtrl) + + if len(tc.mockedDescribeComplianceByConfigRuleResponse) > 0 { + for _, resp := range tc.mockedDescribeComplianceByConfigRuleResponse { + mockConfigServiceAPI.EXPECT().DescribeComplianceByConfigRule(gomock.Any()).Return(resp, tc.mockedDescribeComplianceByConfigRuleError).MaxTimes(1) + } + } else { + mockConfigServiceAPI.EXPECT().DescribeComplianceByConfigRule(gomock.Any()).Return(nil, tc.mockedDescribeComplianceByConfigRuleError).MaxTimes(1) + } + + if len(tc.mockedGetComplianceDetailsByConfigRuleResponse) > 0 { + for _, resp := range tc.mockedGetComplianceDetailsByConfigRuleResponse { + mockConfigServiceAPI.EXPECT().GetComplianceDetailsByConfigRule(gomock.Any()).Return(resp, tc.mockedGetComplianceDetailsByConfigRuleError).MaxTimes(1) + } + } else { + mockConfigServiceAPI.EXPECT().GetComplianceDetailsByConfigRule(gomock.Any()).Return(nil, tc.mockedGetComplianceDetailsByConfigRuleError).MaxTimes(1) + } + + client := &Client{ + AWSConfig: mockConfigServiceAPI, + } + + output, err := client.GetNonComplaintConfigRules() + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} diff --git a/pkg/aws/cloudtrail.go b/pkg/aws/cloudtrail.go new file mode 100644 index 0000000..bf0378a --- /dev/null +++ b/pkg/aws/cloudtrail.go @@ -0,0 +1,34 @@ +package aws + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/cloudtrail" +) + +// CloudTrailSVC is a wrapper for CloudTrail service API calls +type CloudTrailSVC interface { + GetS3LogPrefixForCloudTrail() (*string, error) +} + +// GetS3LogPrefixForCloudTrail retruns a S3Prefix associated with CloudTrail if one available for a region derived from the authenticated session +// and an error if there is any +// https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-find-log-files.html +func (client *Client) GetS3LogPrefixForCloudTrail() (*string, error) { + accountID, err := client.GetAccountID() + if err != nil { + return nil, err + } + fixedPrefix := "/AWSLogs/" + accountID + "/CloudTrail" + result, err := client.CloudTrail.DescribeTrails(&cloudtrail.DescribeTrailsInput{}) + if err != nil { + return nil, err + } + if len(result.TrailList) > 0 { + for _, t := range result.TrailList { + if t.S3BucketName != nil { + return aws.String("s3://" + aws.StringValue(t.S3BucketName) + "/" + aws.StringValue(t.S3KeyPrefix) + fixedPrefix), nil + } + } + } + return nil, nil +} diff --git a/pkg/aws/cloudtrail_test.go b/pkg/aws/cloudtrail_test.go new file mode 100644 index 0000000..4bca4cf --- /dev/null +++ b/pkg/aws/cloudtrail_test.go @@ -0,0 +1,110 @@ +package aws + +import ( + "errors" + "testing" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/cloudtrail" + "github.com/aws/aws-sdk-go/service/sts" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" +) + +func TestGetCloudTrailWithS3Prefix(t *testing.T) { + // sess, _ := NewAuthenticatedSession("us-east-2") + // prefix, err := NewClient(sess).GetCloudTrailWithS3Prefix() + // if err != nil { + // log.Println(err) + // } + // log.Println(prefix) + // t.Fail() + + testCases := []struct { + name string + apiResponse *cloudtrail.DescribeTrailsOutput + expectedOutput *string + expectedError error + }{ + { + name: "emptyResponse#1", + apiResponse: &cloudtrail.DescribeTrailsOutput{}, + expectedOutput: nil, + expectedError: nil, + }, + { + name: "Trial WithOut S3", + apiResponse: &cloudtrail.DescribeTrailsOutput{ + TrailList: []*cloudtrail.Trail{ + { + Name: aws.String("myTestTrail"), + HomeRegion: aws.String("us-east-1"), + IncludeGlobalServiceEvents: aws.Bool(true), + IsMultiRegionTrail: aws.Bool(true), + TrailARN: aws.String("arn:aws:cloudtrail:us-east-1:378456495793:trail/myTestTrail"), + }, + }, + }, + expectedOutput: nil, + expectedError: nil, + }, + { + name: "trialWithS3#2", + apiResponse: &cloudtrail.DescribeTrailsOutput{ + TrailList: []*cloudtrail.Trail{ + { + Name: aws.String("myTestTrail"), + HomeRegion: aws.String("us-east-1"), + IncludeGlobalServiceEvents: aws.Bool(true), + IsMultiRegionTrail: aws.Bool(true), + TrailARN: aws.String("arn:aws:cloudtrail:us-east-1:111111111111:trail/myTestTrail"), + }, + { + Name: aws.String("myTestTrail1"), + HomeRegion: aws.String("us-east-1"), + IncludeGlobalServiceEvents: aws.Bool(true), + IsMultiRegionTrail: aws.Bool(true), + S3BucketName: aws.String("lp-cl-111111111111-us-east-1"), + S3KeyPrefix: aws.String("source=aws/account=111111111111/region=us-east-1/service=cloudtrail"), + TrailARN: aws.String("arn:aws:cloudtrail:us-east-1:111111111111:trail/myTestTrail1"), + }, + }, + }, + expectedOutput: aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + expectedError: nil, + }, + { + name: "errorResponse#3", + apiResponse: nil, + expectedOutput: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockCloudTrailAPI := mocks.NewMockCloudTrailAPI(mockCtrl) + + mockCloudTrailAPI.EXPECT().DescribeTrails(&cloudtrail.DescribeTrailsInput{}).Return(tc.apiResponse, tc.expectedError) + + mockSTSAPI := mocks.NewMockSTSAPI(mockCtrl) + mockSTSAPI.EXPECT().GetCallerIdentity(&sts.GetCallerIdentityInput{}).Return(&sts.GetCallerIdentityOutput{ + Account: aws.String("111111111111"), + Arn: aws.String("arn:aws:sts::111111111111:assumed-role/AWS_111111111111_ReadOnly/test@gmail.com"), + UserId: aws.String("AROAIU4J2NPCGYXQIOPMQ:test@gmail.com"), + }, nil) + + client := &Client{ + CloudTrail: mockCloudTrailAPI, + STS: mockSTSAPI, + } + + output, err := client.GetS3LogPrefixForCloudTrail() + assert.Equal(t, aws.StringValue(tc.expectedOutput), aws.StringValue(output)) + assert.Equal(t, tc.expectedError, err) + }) + } +} diff --git a/pkg/aws/ec2.go b/pkg/aws/ec2.go new file mode 100644 index 0000000..c223131 --- /dev/null +++ b/pkg/aws/ec2.go @@ -0,0 +1,121 @@ +package aws + +import ( + "fmt" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ec2" +) + +// EC2SVC is a wrapper for EC2 API calls +type EC2SVC interface { + GetInstances() (*ec2.DescribeInstancesOutput, error) + GetImageInformation(imageIds []string) (*ec2.DescribeImagesOutput, error) + GetInstancesMatchingAllTags(tags map[string]string) (*ec2.DescribeInstancesOutput, error) + GetInstancesMatchingAnyTags(tags map[string]string) (*ec2.DescribeInstancesOutput, error) + GetInstancesByFilters(ec2Filters map[string][]string) (*ec2.DescribeInstancesOutput, error) +} + +// GetInstances returns a list of EC2 instances and information +func (client *Client) GetInstances() (*ec2.DescribeInstancesOutput, error) { + result, err := client.EC2.DescribeInstances(&ec2.DescribeInstancesInput{}) + if err != nil { + return nil, err + } + + return result, nil +} + +// GetImageInformation returns the information about a list of EC2 imageIds +func (client *Client) GetImageInformation(imageIds []string) (*ec2.DescribeImagesOutput, error) { + output, err := client.EC2.DescribeImages(&ec2.DescribeImagesInput{ImageIds: aws.StringSlice(imageIds)}) + if err != nil { + return nil, err + } + + return output, nil +} + +// GetInstancesMatchingAnyTags returns instances that match ANY tags and their respective values in a given list. +// Ex: "k8s.io/cluster-autoscaler/enabled": "true" AND/OR "terraform": "true" +func (client *Client) GetInstancesMatchingAnyTags(tags map[string]string) (*ec2.DescribeInstancesOutput, error) { + result := &ec2.DescribeInstancesOutput{} + for tag, value := range tags { + response, err := client.GetInstancesByFilters(map[string][]string{fmt.Sprintf("tag:%s", tag): {value}}) + if err != nil { + return nil, err + } + + /* Processing logic + 1. Add reservation if not in existing list + 2. Else check if any instances for a given reservation were not existing list. + * This could mean that the tags for a given instance were changed or updated since being launched + */ + + if len(result.Reservations) > 0 { + for _, reservation := range response.Reservations { + newReservation := false + for _, existingReservation := range result.Reservations { + if *existingReservation.ReservationId != *reservation.ReservationId { + newReservation = true + } else { + newReservation = false + + // Compare instances + for _, instance := range reservation.Instances { + newInstance := false + for _, existingInstance := range existingReservation.Instances { + if *existingInstance.InstanceId == *instance.InstanceId { + newInstance = false + break + } else { + newInstance = true + } + } + if newInstance { + existingReservation.Instances = append(existingReservation.Instances, instance) + } + } + break + } + } + + if newReservation { + result.Reservations = append(result.Reservations, reservation) + } + } + } else { + result.Reservations = append(result.Reservations, response.Reservations...) + } + + } + + return result, nil +} + +// GetInstancesMatchingAllTags returns instances that match ALL tags and their respective values in a given list. +// Ex: "k8s.io/cluster-autoscaler/enabled": "true" AND "terraform": "true" +func (client *Client) GetInstancesMatchingAllTags(tags map[string]string) (*ec2.DescribeInstancesOutput, error) { + ec2Filters := make(map[string][]string, len(tags)) + for tag, value := range tags { + ec2Filters[fmt.Sprintf("tag:%s", tag)] = []string{value} + } + + return client.GetInstancesByFilters(ec2Filters) +} + +// GetInstancesByFilters returns all instances that match a list of EC2 filters +func (client *Client) GetInstancesByFilters(ec2Filters map[string][]string) (*ec2.DescribeInstancesOutput, error) { + // build list of filters + ec2FiltersList := []*ec2.Filter{} + for name, values := range ec2Filters { + ec2FiltersList = append(ec2FiltersList, &ec2.Filter{Name: aws.String(name), Values: aws.StringSlice(values)}) + } + + output, err := client.EC2.DescribeInstances(&ec2.DescribeInstancesInput{Filters: ec2FiltersList}) + if err != nil { + return nil, err + } + + return output, nil +} diff --git a/pkg/aws/ec2_test.go b/pkg/aws/ec2_test.go new file mode 100644 index 0000000..b40c329 --- /dev/null +++ b/pkg/aws/ec2_test.go @@ -0,0 +1,708 @@ +package aws + +import ( + "errors" + "fmt" + "reflect" + "sort" + "testing" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ec2" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" +) + +func TestGetInstances(t *testing.T) { + testCases := []struct { + name string + output *ec2.DescribeInstancesOutput + expectedError error + }{ + { + name: "Empty response", + output: &ec2.DescribeInstancesOutput{}, + expectedError: nil, + }, + { + name: "Populated response", + output: &ec2.DescribeInstancesOutput{Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + Platform: aws.String("Linux"), + IamInstanceProfile: &ec2.IamInstanceProfile{ + Arn: aws.String("arn:aws:iam::111111111111:instance-profile/test-profile"), + Id: aws.String("AIPAJO5KIRR7I5NITEST"), + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI-2"), + InstanceId: aws.String("i-00000test000001111"), + Platform: aws.String("Linux2"), + IamInstanceProfile: &ec2.IamInstanceProfile{ + Arn: aws.String("arn:aws:iam::111111111111:instance-profile/test-profile-1"), + Id: aws.String("AIPAJO5KIRR7I5NITEST1"), + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629ctest1"), + }, + }}, + expectedError: nil, + }, + { + name: "Error response", + output: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockEC2API := mocks.NewMockEC2API(mockCtrl) + mockEC2API.EXPECT().DescribeInstances(&ec2.DescribeInstancesInput{}).Return(tc.output, tc.expectedError) + client := &Client{ + EC2: mockEC2API, + } + + output, err := client.GetInstances() + assert.Equal(t, tc.output, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestGetInstancesByFilters(t *testing.T) { + testCases := []struct { + name string + input map[string][]string + output *ec2.DescribeInstancesOutput + expectedError error + }{ + { + name: "Empty response", + input: map[string][]string{ + "availability-zone": {"us-east-1a", "us-east-1b"}, + }, + output: &ec2.DescribeInstancesOutput{}, + expectedError: nil, + }, + { + name: "Populated response", + input: map[string][]string{ + "availability-zone": {"us-east-1a", "us-east-1b"}, + "instance-type": {"m5.large"}, + }, + output: &ec2.DescribeInstancesOutput{Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + InstanceType: aws.String("m5.large"), + Placement: &ec2.Placement{ + AvailabilityZone: aws.String("us-east-1a"), + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI-2"), + InstanceId: aws.String("i-00000test000001111"), + InstanceType: aws.String("m5.large"), + Placement: &ec2.Placement{ + AvailabilityZone: aws.String("us-east-1b"), + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629ctest1"), + }, + }}, + expectedError: nil, + }, + { + name: "Error response", + + input: map[string][]string{ + "instance-type": {"m5.large"}, + }, + output: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockEC2API := mocks.NewMockEC2API(mockCtrl) + + // Build list of filters + ec2FiltersList := []*ec2.Filter{} + // Maps, when indexed with range, might not always output in the right order + // Thus to fix this test, we can add a second input check with the reversed filters + // As there exists only 2 filters, this covers all possible orderings + ec2FiltersList2 := []*ec2.Filter{} + for name, values := range tc.input { + ec2FiltersList = append(ec2FiltersList, &ec2.Filter{Name: aws.String(name), Values: aws.StringSlice(values)}) + } + for i := (len(ec2FiltersList) - 1); i >= 0; i-- { + ec2FiltersList2 = append(ec2FiltersList2, ec2FiltersList[i]) + } + + mockEC2API.EXPECT().DescribeInstances(&ec2.DescribeInstancesInput{Filters: ec2FiltersList}).Return(tc.output, tc.expectedError).MaxTimes(1) + mockEC2API.EXPECT().DescribeInstances(&ec2.DescribeInstancesInput{Filters: ec2FiltersList2}).Return(tc.output, tc.expectedError).MaxTimes(1) + client := &Client{ + EC2: mockEC2API, + } + + output, err := client.GetInstancesByFilters(tc.input) + assert.Equal(t, tc.output, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestGetInstancesMatchingAnyTags(t *testing.T) { + type input struct { + tags map[string]string + } + testCases := []struct { + name string + input input + describeInstancesOutputs []*ec2.DescribeInstancesOutput + expectedOutput *ec2.DescribeInstancesOutput + expectedError error + }{ + { + name: "Return correct result", + input: input{ + tags: map[string]string{ + "aws_inspector": "true", + "terraform": "true", + }, + }, + describeInstancesOutputs: []*ec2.DescribeInstancesOutput{ + { + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + }, + }, + { + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test0000001111"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + { + ImageId: aws.String("TEST_AMI-2"), + InstanceId: aws.String("i-00000test000002222"), + InstanceType: aws.String("m5.xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test1"), + }, + }, + }, + }, + expectedOutput: &ec2.DescribeInstancesOutput{ + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test0000001111"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + { + ImageId: aws.String("TEST_AMI-2"), + InstanceId: aws.String("i-00000test000002222"), + InstanceType: aws.String("m5.xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test1"), + }, + }, + }, + expectedError: nil, + }, + { + name: "Return correct result if a reservation has an instance with different tags that do not match other instances", + input: input{ + tags: map[string]string{ + "aws_inspector": "true", + "terraform": "true", + }, + }, + describeInstancesOutputs: []*ec2.DescribeInstancesOutput{ + { + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + }, + }, + { + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI-2"), + InstanceId: aws.String("i-00000test000001111"), + InstanceType: aws.String("m5.xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + }, + }, + }, + expectedOutput: &ec2.DescribeInstancesOutput{ + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + { + ImageId: aws.String("TEST_AMI-2"), + InstanceId: aws.String("i-00000test000001111"), + InstanceType: aws.String("m5.xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + }, + }, + expectedError: nil, + }, + { + name: "Error response", + input: input{ + tags: map[string]string{ + "aws_inspector": "true", + "terraform": "true", + }, + }, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockEC2API := mocks.NewMockEC2API(mockCtrl) + + ec2FiltersList := []*ec2.Filter{} + for tag, value := range tc.input.tags { + ec2FiltersList = append(ec2FiltersList, &ec2.Filter{Name: aws.String(fmt.Sprintf("tag:%s", tag)), Values: aws.StringSlice([]string{value})}) + } + + // Simulate calls made for each tag + if len(tc.describeInstancesOutputs) > 0 { + for i := range ec2FiltersList { + mockEC2API.EXPECT().DescribeInstances(&ec2.DescribeInstancesInput{Filters: []*ec2.Filter{ec2FiltersList[i]}}).Return(tc.describeInstancesOutputs[i], tc.expectedError).MaxTimes(len(ec2FiltersList)) + } + } else { + // Error case + mockEC2API.EXPECT().DescribeInstances(gomock.Any()).Return(tc.expectedOutput, tc.expectedError).MaxTimes(1) + } + + client := &Client{ + EC2: mockEC2API, + } + + // Sort output to match with expected output (only for non-error cases) + // reflect.DeepEqual is not able to handle deeply nested slices of structs. + // This causes an error as their order can change from run to run + output, err := client.GetInstancesMatchingAnyTags(tc.input.tags) + if len(tc.describeInstancesOutputs) > 0 { + sort.SliceStable(output.Reservations, func(i, j int) bool { + return *output.Reservations[i].ReservationId < *output.Reservations[j].ReservationId + }) + + for _, res := range output.Reservations { + sort.SliceStable(res.Instances, func(i, j int) bool { + return *res.Instances[i].InstanceId < *res.Instances[j].InstanceId + }) + } + } + + if !reflect.DeepEqual(tc.expectedOutput, output) { + t.Errorf("Expected %v, got %v", tc.expectedOutput, output) + } + assert.Equal(t, tc.expectedError, err) + }) + } +} +func TestGetInstancesMatchingAllTags(t *testing.T) { + type input struct { + tags map[string]string + } + testCases := []struct { + name string + input input + describeInstancesOutput *ec2.DescribeInstancesOutput + expectedOutput *ec2.DescribeInstancesOutput + expectedError error + }{ + { + name: "Return correct result", + input: input{ + tags: map[string]string{ + "aws_inspector": "true", + "terraform": "true", + }, + }, + describeInstancesOutput: &ec2.DescribeInstancesOutput{ + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI-2"), + InstanceId: aws.String("i-00000test000001111"), + InstanceType: aws.String("m5.xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test1"), + }, + }, + }, + expectedOutput: &ec2.DescribeInstancesOutput{ + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI"), + InstanceId: aws.String("i-00000test000000000"), + InstanceType: aws.String("m5.2xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test"), + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("TEST_AMI-2"), + InstanceId: aws.String("i-00000test000001111"), + InstanceType: aws.String("m5.xlarge"), + Tags: []*ec2.Tag{ + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + { + Key: aws.String("terraform"), + Value: aws.String("true"), + }, + }, + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-testf4fe629c3test1"), + }, + }, + }, + expectedError: nil, + }, + { + name: "Error response", + input: input{ + tags: map[string]string{ + "aws_inspector": "true", + "terraform": "true", + }, + }, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockEC2API := mocks.NewMockEC2API(mockCtrl) + + // Maps, when indexed with range, might not always output in the right order + // This will cause the expected input DescribeInstances to fail if the resulting map is in a different order than expected + // To fix this, we will sort the ec2 filter + ec2FiltersList := []*ec2.Filter{} + for tag, value := range tc.input.tags { + ec2FiltersList = append(ec2FiltersList, &ec2.Filter{Name: aws.String(fmt.Sprintf("tag:%s", tag)), Values: aws.StringSlice([]string{value})}) + } + ec2FiltersList2 := []*ec2.Filter{} + for i := (len(ec2FiltersList) - 1); i >= 0; i-- { + ec2FiltersList2 = append(ec2FiltersList2, ec2FiltersList[i]) + } + + mockEC2API.EXPECT().DescribeInstances(&ec2.DescribeInstancesInput{Filters: ec2FiltersList}).Return(tc.describeInstancesOutput, tc.expectedError).MaxTimes(1) + mockEC2API.EXPECT().DescribeInstances(&ec2.DescribeInstancesInput{Filters: ec2FiltersList2}).Return(tc.describeInstancesOutput, tc.expectedError).MaxTimes(1) + + client := &Client{ + EC2: mockEC2API, + } + + output, err := client.GetInstancesMatchingAllTags(tc.input.tags) + if !reflect.DeepEqual(tc.expectedOutput, output) { + t.Errorf("Expected %v, got %v", tc.expectedOutput, output) + } + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestGetImageInformation(t *testing.T) { + testCases := []struct { + name string + input []string + output *ec2.DescribeImagesOutput + expectedError error + }{ + { + name: "Empty response", + input: []string{"TEST_AMI-1", "TEST_AMI-2"}, + output: &ec2.DescribeImagesOutput{}, + expectedError: nil, + }, + { + name: "Populated response", + input: []string{"TEST_AMI-1", "TEST_AMI-2"}, + output: &ec2.DescribeImagesOutput{ + Images: []*ec2.Image{ + { + ImageId: aws.String("TEST_AMI-1"), + }, + { + ImageId: aws.String("TEST_AMI-2"), + }, + }, + }, + expectedError: nil, + }, + { + name: "Error response", + input: []string{"TEST_AMI-1", "TEST_AMI-2"}, + output: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockEC2API := mocks.NewMockEC2API(mockCtrl) + mockEC2API.EXPECT().DescribeImages(&ec2.DescribeImagesInput{ImageIds: aws.StringSlice(tc.input)}).Return(tc.output, tc.expectedError) + client := &Client{ + EC2: mockEC2API, + } + + output, err := client.GetImageInformation(tc.input) + assert.Equal(t, tc.output, output) + assert.Equal(t, tc.expectedError, err) + }) + } + +} diff --git a/pkg/aws/ecr.go b/pkg/aws/ecr.go new file mode 100644 index 0000000..cdfe12b --- /dev/null +++ b/pkg/aws/ecr.go @@ -0,0 +1,68 @@ +package aws + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ecr" +) + +// ECRSVC is a wrapper for ECR Image Scan API calls +type ECRSVC interface { + GetECRImagesWithTag(tag string) (map[string][]*ecr.ImageDetail, error) +} + +// GetECRImagesWithTag finds all ECR images with a given tag. If no tag specified, all tagged images are returned +func (client *Client) GetECRImagesWithTag(tag string) (map[string][]*ecr.ImageDetail, error) { + var reposNextToken *string + var imagesNextToken *string + images := make(map[string][]*ecr.ImageDetail) + + for { + reposResp, err := client.ECR.DescribeRepositories(&ecr.DescribeRepositoriesInput{ + NextToken: reposNextToken, + }) + + if err != nil { + return nil, err + } + + for _, repo := range reposResp.Repositories { + for { + imagesResp, err := client.ECR.DescribeImages(&ecr.DescribeImagesInput{ + NextToken: imagesNextToken, + RegistryId: repo.RegistryId, + RepositoryName: repo.RepositoryName, + Filter: &ecr.DescribeImagesFilter{ + TagStatus: aws.String("TAGGED"), + }, + }) + + if err != nil { + return nil, err + } + + // Find images matching a given tag. If no tag specified, return all tagged images + if tag != "" { + for _, image := range imagesResp.ImageDetails { + if Contains(aws.StringValueSlice(image.ImageTags), tag) { + images[*repo.RepositoryUri] = append(images[*repo.RepositoryUri], image) + } + } + } else { + images[*repo.RepositoryUri] = append(images[*repo.RepositoryUri], imagesResp.ImageDetails...) + } + + imagesNextToken = imagesResp.NextToken + if imagesNextToken == nil { + break + } + } + } + + reposNextToken = reposResp.NextToken + if reposNextToken == nil { + break + } + } + + return images, nil +} diff --git a/pkg/aws/ecr_test.go b/pkg/aws/ecr_test.go new file mode 100644 index 0000000..0d39260 --- /dev/null +++ b/pkg/aws/ecr_test.go @@ -0,0 +1,225 @@ +package aws + +import ( + "errors" + "reflect" + "testing" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ecr" + "github.com/golang/mock/gomock" +) + +func TestClient_GetECRImagesWithTag(t *testing.T) { + tests := []struct { + name string + tag string + describeRepositoriesResponses []*ecr.DescribeRepositoriesOutput + describeRepositoriesResponsesError error + describeImagesResponses []*ecr.DescribeImagesOutput + describeImagesResponsesError error + want map[string][]*ecr.ImageDetail + wantErr bool + }{ + { + name: "Return all images with tag", + tag: "test", + describeRepositoriesResponses: []*ecr.DescribeRepositoriesOutput{ + { + NextToken: aws.String("123"), + Repositories: []*ecr.Repository{ + { + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + RepositoryUri: aws.String("012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server"), + }, + }, + }, + { + Repositories: []*ecr.Repository{ + { + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/hello-world"), + RepositoryUri: aws.String("012345678910.dkr.ecr.us-east-1.amazonaws.com/app/hello-world"), + }, + }, + }, + }, + describeImagesResponses: []*ecr.DescribeImagesOutput{ + { + NextToken: aws.String("456"), + ImageDetails: []*ecr.ImageDetail{ + { + ImageTags: aws.StringSlice([]string{"v1"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + { + ImageTags: aws.StringSlice([]string{"stage-canary", "test"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + }, + }, + { + ImageDetails: []*ecr.ImageDetail{ + { + ImageTags: aws.StringSlice([]string{"prod-canary"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + }, + }, + { + ImageDetails: []*ecr.ImageDetail{ + { + ImageTags: aws.StringSlice([]string{"test"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/hello-world"), + }, + }, + }, + }, + want: map[string][]*ecr.ImageDetail{ + "012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server": { + { + ImageTags: aws.StringSlice([]string{"stage-canary", "test"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + }, + "012345678910.dkr.ecr.us-east-1.amazonaws.com/app/hello-world": { + { + ImageTags: aws.StringSlice([]string{"test"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/hello-world"), + }, + }, + }, + wantErr: false, + }, + { + name: "Return all tagged images when no specific tag specified", + describeRepositoriesResponses: []*ecr.DescribeRepositoriesOutput{ + { + Repositories: []*ecr.Repository{ + { + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + RepositoryUri: aws.String("012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server"), + }, + }, + }, + }, + describeImagesResponses: []*ecr.DescribeImagesOutput{ + { + NextToken: aws.String("456"), + ImageDetails: []*ecr.ImageDetail{ + { + ImageTags: aws.StringSlice([]string{"v1"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + { + ImageTags: aws.StringSlice([]string{"stage-canary", "test"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + }, + }, + { + ImageDetails: []*ecr.ImageDetail{ + { + ImageTags: aws.StringSlice([]string{"prod-canary"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + }, + }, + }, + want: map[string][]*ecr.ImageDetail{ + "012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server": { + { + ImageTags: aws.StringSlice([]string{"v1"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + { + ImageTags: aws.StringSlice([]string{"stage-canary", "test"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + { + ImageTags: aws.StringSlice([]string{"prod-canary"}), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + }, + }, + }, + wantErr: false, + }, + { + name: "Return error if DescribeRepositories call fails", + describeRepositoriesResponsesError: errors.New("some API error"), + want: nil, + wantErr: true, + }, + { + name: "Return error if DescribeImages call fails", + describeRepositoriesResponses: []*ecr.DescribeRepositoriesOutput{ + { + Repositories: []*ecr.Repository{ + { + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + RepositoryUri: aws.String("012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server"), + }, + }, + }, + }, + describeImagesResponsesError: errors.New("some API error"), + want: nil, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockECRAPI := mocks.NewMockECRAPI(mockCtrl) + + // Simulate responses from ECR APIs + if len(tt.describeRepositoriesResponses) > 0 { + for _, resp := range tt.describeRepositoriesResponses { + mockECRAPI.EXPECT().DescribeRepositories(gomock.Any()).Return(resp, tt.describeRepositoriesResponsesError).MaxTimes(1) + } + } else { + mockECRAPI.EXPECT().DescribeRepositories(gomock.Any()).Return(nil, tt.describeRepositoriesResponsesError).MaxTimes(1) + } + + if len(tt.describeImagesResponses) > 0 { + for _, resp := range tt.describeImagesResponses { + mockECRAPI.EXPECT().DescribeImages(gomock.Any()).Return(resp, tt.describeImagesResponsesError).MaxTimes(1) + } + } else { + mockECRAPI.EXPECT().DescribeImages(gomock.Any()).Return(nil, tt.describeImagesResponsesError).MaxTimes(1) + } + + client := &Client{ + ECR: mockECRAPI, + } + + got, err := client.GetECRImagesWithTag(tt.tag) + if (err != nil) != tt.wantErr { + t.Errorf("GetECRImagesWithTag() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("GetECRImagesWithTag() got = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/aws/health.go b/pkg/aws/health.go new file mode 100644 index 0000000..4b70430 --- /dev/null +++ b/pkg/aws/health.go @@ -0,0 +1,68 @@ +package aws + +import ( + "errors" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/health" +) + +// HealthSVC is a wrapper for Support API calls related to Health Notifactions +type HealthSVC interface { + GetHealthEvents(eventFilter *health.EventFilter, nextToken *string) (*health.DescribeEventsOutput, error) + GetHealthEventDetails(arnArr []*string) (*health.DescribeEventDetailsOutput, error) + GetHealthAffectedEntities(arnArr []*string, nextToken *string) (*health.DescribeAffectedEntitiesOutput, error) +} + +// GetHealthEvents returns a list of Health notification events +func (client *Client) GetHealthEvents(eventFilter *health.EventFilter, nextToken *string) (*health.DescribeEventsOutput, error) { + if eventFilter == nil { + eventFilter = &health.EventFilter{ + EventTypeCategories: []*string{aws.String("accountNotification")}, + EventStatusCodes: []*string{aws.String("open"), aws.String("upcoming")}, + } + } + result, err := client.Health.DescribeEvents(&health.DescribeEventsInput{ + Filter: eventFilter, + MaxResults: aws.Int64(100), // Max event results per api is 100 + NextToken: nextToken, + }) + if err != nil { + return nil, err + } + + return result, nil +} + +// GetHealthEventDetails returns a list of Health notification events +func (client *Client) GetHealthEventDetails(arnArr []*string) (*health.DescribeEventDetailsOutput, error) { + if arnArr == nil || len(arnArr) == 0 || len(arnArr) > 10 { + return nil, errors.New("Describe event details can only query for 1-10 event details at a time") + } + result, err := client.Health.DescribeEventDetails(&health.DescribeEventDetailsInput{ + EventArns: arnArr, + }) + if err != nil { + return nil, err + } + + return result, nil +} + +// GetHealthAffectedEntities returns a list of Health notification events +func (client *Client) GetHealthAffectedEntities(arnArr []*string, nextToken *string) (*health.DescribeAffectedEntitiesOutput, error) { + if arnArr == nil || len(arnArr) == 0 || len(arnArr) > 100 { + return nil, errors.New("Describe affected entities can only query for 1-100 event details at a time") + } + result, err := client.Health.DescribeAffectedEntities(&health.DescribeAffectedEntitiesInput{ + Filter: &health.EntityFilter{ + EventArns: arnArr, + }, + NextToken: nextToken, + }) + if err != nil { + return nil, err + } + + return result, nil +} diff --git a/pkg/aws/health_test.go b/pkg/aws/health_test.go new file mode 100644 index 0000000..f8b0658 --- /dev/null +++ b/pkg/aws/health_test.go @@ -0,0 +1,207 @@ +package aws + +import ( + "errors" + "testing" + + "github.com/aws/aws-sdk-go/aws" + + "github.com/Optum/cloudig/pkg/mocks" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/service/health" +) + +func TestGetHealthEvents(t *testing.T) { + testCases := []struct { + name string + input *string + output *health.DescribeEventsOutput + expectedError error + }{ + { + name: "Return Events with a next token", + input: aws.String("a token"), + output: &health.DescribeEventsOutput{ + Events: []*health.Event{{ + Arn: aws.String("arn1"), + }}, + }, + expectedError: nil, + }, + { + name: "Return Events with no next token", + input: nil, + output: &health.DescribeEventsOutput{ + Events: []*health.Event{{ + Arn: aws.String("arn1"), + }}, + }, + expectedError: nil, + }, + { + name: "Return error", + input: nil, + output: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockHealthAPI := mocks.NewMockHealthAPI(mockCtrl) + mockHealthAPI.EXPECT().DescribeEvents(&health.DescribeEventsInput{ + Filter: &health.EventFilter{ + EventTypeCategories: []*string{aws.String("accountNotification")}, + EventStatusCodes: []*string{aws.String("open"), aws.String("upcoming")}, + }, + MaxResults: aws.Int64(100), + NextToken: tc.input, + }).Return(tc.output, tc.expectedError) + client := &Client{ + Health: mockHealthAPI, + } + + output, err := client.GetHealthEvents(nil, tc.input) + assert.Equal(t, tc.output, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestGetHealthEventDetails(t *testing.T) { + testCases := []struct { + name string + input []*string + output *health.DescribeEventDetailsOutput + expectedError error + }{ + { + name: "Return Events with a next token", + input: []*string{aws.String("arn1"), aws.String("arn2")}, + output: &health.DescribeEventDetailsOutput{ + SuccessfulSet: []*health.EventDetails{ + { + Event: &health.Event{ + Arn: aws.String("arn1"), + }, + }, + { + Event: &health.Event{ + Arn: aws.String("arn2"), + }, + }, + }, + }, + expectedError: nil, + }, + { + name: "Return error", + input: []*string{aws.String("arn1"), aws.String("arn2")}, + output: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockHealthAPI := mocks.NewMockHealthAPI(mockCtrl) + mockHealthAPI.EXPECT().DescribeEventDetails(&health.DescribeEventDetailsInput{ + EventArns: []*string{aws.String("arn1"), aws.String("arn2")}, + }).Return(tc.output, tc.expectedError) + client := &Client{ + Health: mockHealthAPI, + } + + output, err := client.GetHealthEventDetails(tc.input) + assert.Equal(t, tc.output, output) + assert.Equal(t, tc.expectedError, err) + }) + } + // test case where function is not hit + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockHealthAPI := mocks.NewMockHealthAPI(mockCtrl) + client := &Client{ + Health: mockHealthAPI, + } + output, err := client.GetHealthEventDetails(nil) + var outputNilType *health.DescribeEventDetailsOutput + assert.Equal(t, outputNilType, output) + assert.Equal(t, errors.New("Describe event details can only query for 1-10 event details at a time"), err) +} + +func TestGetHealthAffectedEntities(t *testing.T) { + testCases := []struct { + name string + inputArnArr []*string + inputNextToken *string + output *health.DescribeAffectedEntitiesOutput + expectedError error + }{ + { + name: "Return Events with a next token", + inputArnArr: []*string{aws.String("arn1"), aws.String("arn2")}, + inputNextToken: aws.String("Some token"), + output: &health.DescribeAffectedEntitiesOutput{ + Entities: []*health.AffectedEntity{ + { + EventArn: aws.String("arn1"), + }, + { + EventArn: aws.String("arn2"), + }, + }, + }, + expectedError: nil, + }, + { + name: "Return error", + inputArnArr: []*string{aws.String("arn1"), aws.String("arn2")}, + inputNextToken: aws.String("Some token"), + output: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockHealthAPI := mocks.NewMockHealthAPI(mockCtrl) + mockHealthAPI.EXPECT().DescribeAffectedEntities(&health.DescribeAffectedEntitiesInput{ + Filter: &health.EntityFilter{ + EventArns: tc.inputArnArr, + }, + NextToken: tc.inputNextToken, + }).Return(tc.output, tc.expectedError) + client := &Client{ + Health: mockHealthAPI, + } + + output, err := client.GetHealthAffectedEntities(tc.inputArnArr, tc.inputNextToken) + assert.Equal(t, tc.output, output) + assert.Equal(t, tc.expectedError, err) + }) + } + // test case where function is not hit + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockHealthAPI := mocks.NewMockHealthAPI(mockCtrl) + client := &Client{ + Health: mockHealthAPI, + } + output, err := client.GetHealthAffectedEntities(nil, nil) + var outputNilType *health.DescribeAffectedEntitiesOutput + assert.Equal(t, outputNilType, output) + assert.Equal(t, errors.New("Describe affected entities can only query for 1-100 event details at a time"), err) +} diff --git a/pkg/aws/iam.go b/pkg/aws/iam.go new file mode 100644 index 0000000..d106a4a --- /dev/null +++ b/pkg/aws/iam.go @@ -0,0 +1,274 @@ +package aws + +import ( + "encoding/json" + "math" + "net/url" + "strings" + "sync" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/iam" +) + +// IAMSVC is a wrapper for IAM API calls +type IAMSVC interface { + GetRolesFromTags(tags map[string]string) ([]string, error) + GetNetIAMPermissionsForRoles(roleARNs []string) map[string][]string +} + +type roleTagResult struct { + roleTags []*iam.Tag + roleARN string + err error +} + +const ( + parallelListRoleTagsAPILimit int = 15 // AWS ratelimit @ 100 call per sec + parallelRolePermissionsAPILimit int = 10 +) + +// GetRolesFromTags returns a list of IAM Roles with tags provided +// Please note, ListRoles doesn't get the tags - https://github.com/aws/aws-sdk-go/issues/2442 +// this would mean calling ListRoleTags API for each role to get the tags +// we call this API in parallel to speed up the overall execution +func (client *Client) GetRolesFromTags(tags map[string]string) ([]string, error) { + result, err := client.IAM.ListRoles(&iam.ListRolesInput{}) + if err != nil { + return nil, err + } + roleARNs := make([]string, 0) + for _, v := range result.Roles { + roleARNs = append(roleARNs, aws.StringValue(v.Arn)) + } + + resultsTruncated := *result.IsTruncated + marker := result.Marker + for resultsTruncated { + result, err := client.IAM.ListRoles(&iam.ListRolesInput{Marker: marker}) + if err != nil { + return nil, err + } + for _, v := range result.Roles { + roleARNs = append(roleARNs, aws.StringValue(v.Arn)) + } + resultsTruncated = *result.IsTruncated + marker = result.Marker + } + // if there are no tags to validate, entire role slice is returned + if len(tags) == 0 { + return roleARNs, nil + } + + output := make(chan roleTagResult, len(roleARNs)) + runInBatches(func(roleARN string) { + ss := strings.Split(roleARN, "/") + result, err := client.IAM.ListRoleTags(&iam.ListRoleTagsInput{RoleName: aws.String(ss[len(ss)-1])}) + output <- roleTagResult{result.Tags, roleARN, err} + }, roleARNs, parallelListRoleTagsAPILimit) + + // close chanel + close(output) + + roleARNsWithTags := make([]string, 0) + // read from the chanel + for v := range output { + if v.err != nil { + return nil, v.err + } + if containsAllTags(tags, v.roleTags) { + roleARNsWithTags = append(roleARNsWithTags, v.roleARN) + } + } + return roleARNsWithTags, nil +} + +// containsAllTags find if given map of tags are present in slice of IAM tag +func containsAllTags(checkTags map[string]string, roleTags []*iam.Tag) bool { + if len(checkTags) == 0 { + return true + } + for k, v := range checkTags { + if !containsTag(roleTags, k, v) { + return false + } + } + return true +} + +// containsTag find if given key and value present in slice of IAM tag +func containsTag(tags []*iam.Tag, k, v string) bool { + for _, tag := range tags { + if k == *tag.Key && v == *tag.Value { + return true + } + } + return false +} + +type rolePermissionResult struct { + roleARN string + permissions []string + err error +} + +// GetNetIAMPermissionsForRoles returns the IAM permissions for each role attached via different polices +func (client *Client) GetNetIAMPermissionsForRoles(roleARNs []string) map[string][]string { + // loop over each role and get all polices for a role + // call getNetIAMRolePermissions(client *Client,roleARN string) ([]string,error) + + output := make(chan rolePermissionResult, len(roleARNs)) + runInBatches(func(roleARN string) { + ss := strings.Split(roleARN, "/") + result, err := client.getNetIAMRolePermissions(ss[len(ss)-1]) + output <- rolePermissionResult{roleARN, result, err} + }, roleARNs, parallelRolePermissionsAPILimit) + + // close chanel + close(output) + + permissions := make(map[string][]string, 0) + // read from the channel + for v := range output { + if v.err != nil { + var errString string + if awsErr, ok := v.err.(awserr.Error); ok { + errString = awsErr.Message() + } else { + errString = v.err.Error() + } + permissions[v.roleARN] = []string{errString} + } else { + permissions[v.roleARN] = v.permissions + } + } + + return permissions +} + +// getNetIAMRolePermissions returns the IAM permissions for the role attached via different polices +func (client *Client) getNetIAMRolePermissions(roleName string) ([]string, error) { + policyDocuments := make([]string, 0) + + // check for inline polices + resultRoleInlinePolices, err := client.IAM.ListRolePolicies(&iam.ListRolePoliciesInput{RoleName: aws.String(roleName)}) + if err != nil { + return nil, err + } + for _, policyName := range resultRoleInlinePolices.PolicyNames { + resultRolePolicy, err := client.IAM.GetRolePolicy(&iam.GetRolePolicyInput{PolicyName: policyName, RoleName: aws.String(roleName)}) + if err != nil { + return nil, err + } + decodedPolicyDoc, err := url.QueryUnescape(aws.StringValue(resultRolePolicy.PolicyDocument)) + if err != nil { + return nil, err + } + policyDocuments = append(policyDocuments, decodedPolicyDoc) + } + + // check for attached policies + resultRoleAttachedPolices, err := client.IAM.ListAttachedRolePolicies(&iam.ListAttachedRolePoliciesInput{RoleName: aws.String(roleName)}) + if err != nil { + return nil, err + } + + // loop through each polices to get the policy document + for _, policy := range resultRoleAttachedPolices.AttachedPolicies { + resultPolicyOutput, err := client.IAM.GetPolicy(&iam.GetPolicyInput{PolicyArn: policy.PolicyArn}) + if err != nil { + return nil, err + } + resultPolicyVersion, err := client.IAM.GetPolicyVersion(&iam.GetPolicyVersionInput{PolicyArn: policy.PolicyArn, VersionId: resultPolicyOutput.Policy.DefaultVersionId}) + if err != nil { + return nil, err + } + decodedPolicyDoc, err := url.QueryUnescape(aws.StringValue(resultPolicyVersion.PolicyVersion.Document)) + if err != nil { + return nil, err + } + policyDocuments = append(policyDocuments, decodedPolicyDoc) + } + + // combine all policy document to get the net permissions + return mergePolicyActions(policyDocuments) +} + +// policyDocument defins the structure for a policy +type policyDocument struct { + Version string + Statement []statementEntry +} + +// statementEntry defins the structure for policy statement +type statementEntry struct { + Effect string + Action interface{} // support both string & []string + Resource interface{} // support both string & []string +} + +// mergePolicyActions combines policy actions from multiple statements and policy document +func mergePolicyActions(policyDocs []string) ([]string, error) { + policyPermission := make([]string, 0) + // loop over policyDocs + for _, policyDoc := range policyDocs { + doc := policyDocument{} + // URL decode each policy doc + + err := json.Unmarshal([]byte(policyDoc), &doc) + if err != nil { + return nil, err + } + + // TODO : handle deny polices + // TODO : include resources + for _, stmt := range doc.Statement { + if stmt.Effect == "Allow" { + switch stmt.Action.(type) { + case []interface{}: + for _, v := range stmt.Action.([]interface{}) { + policyPermission = append(policyPermission, v.(string)) // we can bet on value to be string here + } + case interface{}: + policyPermission = append(policyPermission, stmt.Action.(string)) + default: // possibly nil + //policyPermission = append(policyPermission, stmt.Action.(string)) + } + } + } + } + + return policyPermission, nil +} + +// runInBatches takes a target function and run concurrently with maximum of 'limit' times +// to process the elements from targetSlice +func runInBatches(targetFunc func(string), targetSlice []string, limit int) { + var wg sync.WaitGroup + // determine the number of batches to get the results for all elements + // each batch runs the targetfunction maximum of 'limit' times to get the results + batchSize := int(math.Ceil(float64(len(targetSlice) / limit))) + // total elements left to process + elementsLeft := len(targetSlice) + elementsIndex := 0 + for batchSize != -1 { + // loopsize is going to be same as limit except for the last loop to capture the reminder + loopSize := limit + if elementsLeft < limit { + loopSize = elementsLeft + } + wg.Add(loopSize) + for i := 0; i < loopSize; i++ { + go func(e string) { + defer wg.Done() + targetFunc(e) + + }(targetSlice[elementsIndex]) + elementsIndex++ + } + wg.Wait() + batchSize-- + elementsLeft = elementsLeft - limit + } +} diff --git a/pkg/aws/iam_test.go b/pkg/aws/iam_test.go new file mode 100644 index 0000000..b2a02bc --- /dev/null +++ b/pkg/aws/iam_test.go @@ -0,0 +1,687 @@ +package aws + +import ( + "reflect" + "testing" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/iam" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" +) + +func TestClient_GetRolesFromTags(t *testing.T) { + // sess, _ := NewAuthenticatedSession("us-east-1") + // roles, err := NewClient(sess).GetRolesFromTags(map[string]string{"terraform": "true"}) + // if err != nil { + // log.Fatal(err) + // } + // log.Println(roles, len(roles)) + // t.Fail() + type args struct { + tags map[string]string + } + tests := []struct { + name string + args args + apiListRolesResponse *iam.ListRolesOutput + apiListRoleTagsResponse *iam.ListRoleTagsOutput + want []string + wantErr bool + }{ + { + name: "noTags#1", + args: args{tags: map[string]string{}}, + apiListRolesResponse: &iam.ListRolesOutput{ + Roles: []*iam.Role{ + {Arn: aws.String("arn:aws:iam::111111111111:role/SecurityAutomationLambda-stage"), RoleName: aws.String("SecurityAutomationLambda-stage")}, + {Arn: aws.String("arn:aws:iam::111111111111:role/SESLogstream-okra"), RoleName: aws.String("SESLogstream-okra")}, + {Arn: aws.String("arn:aws:iam::111111111111:role/eks-managed-dig-green-okra"), RoleName: aws.String("eks-managed-dig-green-okra")}, + }, + IsTruncated: aws.Bool(false), + }, + apiListRoleTagsResponse: &iam.ListRoleTagsOutput{Tags: []*iam.Tag{ + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("version"), Value: aws.String("1.1")}, + }}, + want: []string{"arn:aws:iam::111111111111:role/SecurityAutomationLambda-stage", "arn:aws:iam::111111111111:role/SESLogstream-okra", "arn:aws:iam::111111111111:role/eks-managed-dig-green-okra"}, + wantErr: false, + }, + { + name: "singleTag#2", + args: args{tags: map[string]string{"terraform": "true"}}, + apiListRolesResponse: &iam.ListRolesOutput{ + Roles: []*iam.Role{ + {Arn: aws.String("arn:aws:iam::111111111111:role/SecurityAutomationLambda-stage"), RoleName: aws.String("SecurityAutomationLambda-stage")}, + {Arn: aws.String("arn:aws:iam::111111111111:role/SESLogstream-okra"), RoleName: aws.String("SESLogstream-okra")}, + {Arn: aws.String("arn:aws:iam::111111111111:role/eks-managed-dig-green-okra"), RoleName: aws.String("eks-managed-dig-green-okra")}, + }, + IsTruncated: aws.Bool(false), + }, + apiListRoleTagsResponse: &iam.ListRoleTagsOutput{Tags: []*iam.Tag{ + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("version"), Value: aws.String("1.1")}, + }}, + want: []string{"arn:aws:iam::111111111111:role/SecurityAutomationLambda-stage", "arn:aws:iam::111111111111:role/SESLogstream-okra", "arn:aws:iam::111111111111:role/eks-managed-dig-green-okra"}, + wantErr: false, + }, + { + name: "multiTag#3", + args: args{tags: map[string]string{"terraform": "true", "version": "1.1"}}, + apiListRolesResponse: &iam.ListRolesOutput{ + Roles: []*iam.Role{ + {Arn: aws.String("arn:aws:iam::111111111111:role/SecurityAutomationLambda-stage"), RoleName: aws.String("SecurityAutomationLambda-stage")}, + {Arn: aws.String("arn:aws:iam::111111111111:role/SESLogstream-okra"), RoleName: aws.String("SESLogstream-okra")}, + {Arn: aws.String("arn:aws:iam::111111111111:role/eks-managed-dig-green-okra"), RoleName: aws.String("eks-managed-dig-green-okra")}, + }, + IsTruncated: aws.Bool(false), + }, + apiListRoleTagsResponse: &iam.ListRoleTagsOutput{Tags: []*iam.Tag{ + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("version"), Value: aws.String("1.1")}, + }}, + want: []string{"arn:aws:iam::111111111111:role/SecurityAutomationLambda-stage", "arn:aws:iam::111111111111:role/SESLogstream-okra", "arn:aws:iam::111111111111:role/eks-managed-dig-green-okra"}, + wantErr: false, + }, + { + name: "multiTag#4", + args: args{tags: map[string]string{"terraform": "true", "version": "1.2"}}, + apiListRolesResponse: &iam.ListRolesOutput{ + Roles: []*iam.Role{ + {Arn: aws.String("arn:aws:iam::111111111111:role/SecurityAutomationLambda-stage"), RoleName: aws.String("SecurityAutomationLambda-stage")}, + {Arn: aws.String("arn:aws:iam::111111111111:role/SESLogstream-okra"), RoleName: aws.String("SESLogstream-okra")}, + {Arn: aws.String("arn:aws:iam::111111111111:role/eks-managed-dig-green-okra"), RoleName: aws.String("eks-managed-dig-green-okra")}, + }, + IsTruncated: aws.Bool(false), + }, + apiListRoleTagsResponse: &iam.ListRoleTagsOutput{Tags: []*iam.Tag{ + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("version"), Value: aws.String("1.1")}, + }}, + want: []string{}, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockIAMAPI := mocks.NewMockIAMAPI(mockCtrl) + mockIAMAPI.EXPECT().ListRoles(&iam.ListRolesInput{}).Return(tt.apiListRolesResponse, nil) + for _, v := range tt.apiListRolesResponse.Roles { + mockIAMAPI.EXPECT().ListRoleTags(&iam.ListRoleTagsInput{RoleName: v.RoleName}).Return(tt.apiListRoleTagsResponse, nil).AnyTimes() + } + client := &Client{ + IAM: mockIAMAPI, + } + got, err := client.GetRolesFromTags(tt.args.tags) + if (err != nil) != tt.wantErr { + t.Errorf("Client.GetRolesFromTags() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !assert.ElementsMatch(t, got, tt.want) { + t.Errorf("Client.GetRolesFromTags() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_containsAllTags(t *testing.T) { + type args struct { + checkTags map[string]string + roleTags []*iam.Tag + } + tests := []struct { + name string + args args + want bool + }{ + { + name: "present#1", + args: args{ + checkTags: map[string]string{"terraform": "true", "accountType": "prod"}, + roleTags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + }, + want: true, + }, + { + name: "present#2", + args: args{ + checkTags: map[string]string{"launchPad": "true", "version": "1.2"}, + roleTags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + }, + want: true, + }, + { + name: "missingTag#3", + args: args{ + checkTags: map[string]string{"launchPad": "true", "version": "1.3", "sts": "true"}, + roleTags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + }, + want: false, + }, + { + name: "wrongValue#4", + args: args{ + checkTags: map[string]string{"launchPad": "true", "version": "1.3"}, + roleTags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + }, + want: false, + }, + { + name: "wrongkey#5", + args: args{ + checkTags: map[string]string{"launchPad": "true", "versions": "1.2"}, + roleTags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + }, + want: false, + }, + { + name: "lowecase#6", + args: args{ + checkTags: map[string]string{"launchpad": "true", "versions": "1.2"}, + roleTags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + }, + want: false, + }, + { + name: "noRoleTags#7", + args: args{ + checkTags: map[string]string{"launchPad": "true", "versions": "1.2"}, + roleTags: []*iam.Tag{}, + }, + want: false, + }, + { + name: "noCheckTags#8", + args: args{ + checkTags: map[string]string{}, + roleTags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + }, + want: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := containsAllTags(tt.args.checkTags, tt.args.roleTags); got != tt.want { + t.Errorf("containsAllTags() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_containsTag(t *testing.T) { + type args struct { + tags []*iam.Tag + k string + v string + } + tests := []struct { + name string + args args + want bool + }{ + { + name: "present#1", + args: args{ + tags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + k: "terraform", + v: "true", + }, + want: true, + }, + { + name: "present#2", + args: args{ + tags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + k: "accountType", + v: "prod", + }, + want: true, + }, + { + name: "wrongValue#3", + args: args{ + tags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + k: "terraform", + v: "false", + }, + want: false, + }, + { + name: "wrongkey#4", + args: args{ + tags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + k: "versions", + v: "1.2", + }, + want: false, + }, + { + name: "lowecase#5", + args: args{ + tags: []*iam.Tag{ + {Key: aws.String("launchPad"), Value: aws.String("true")}, + {Key: aws.String("terraform"), Value: aws.String("true")}, + {Key: aws.String("accountType"), Value: aws.String("prod")}, + {Key: aws.String("version"), Value: aws.String("1.2")}, + }, + k: "accountType", + v: "Prod", + }, + want: false, + }, + { + name: "noRoleTags#6", + args: args{ + tags: []*iam.Tag{}, + k: "accountType", + v: "Prod", + }, + want: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := containsTag(tt.args.tags, tt.args.k, tt.args.v); got != tt.want { + t.Errorf("containsTag() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_mergePolicyActions(t *testing.T) { + type args struct { + policyDocs []string + } + tests := []struct { + name string + args args + want []string + wantErr bool + }{ + { + name: "simplePolicy#1", + args: args{[]string{ + `{ + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": "*", + "Resource": "*" + } + ] + }`, + }}, + want: []string{"*"}, + wantErr: false, + }, + { + name: "complexPolicy#2", + args: args{[]string{ + `{ + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": "*", + "Resource": "*" + } + ] + }`, + `{ + "Version": "2012-10-17", + "Statement": [ + { + "Sid": "", + "Effect": "Allow", + "Action": [ + "s3:PutObject", + "s3:ListBucket", + "s3:GetObject", + "s3:GetBucketAcl", + "s3:DeleteObject" + ], + "Resource": [ + "arn:aws:s3:::dig-stage-dsfds/*", + "arn:aws:s3:::dig-stage-sdfdsf" + ] + }, + { + "Sid": "", + "Effect": "Allow", + "Action": "events:PutEvents", + "Resource": "*" + } + ] + } + `, + }}, + want: []string{"*", "s3:PutObject", "s3:ListBucket", "s3:GetObject", "s3:GetBucketAcl", "s3:DeleteObject", "events:PutEvents"}, + wantErr: false, + }, + { + name: "errorPolicy#3", + args: args{[]string{ + `{ + "Version": "2012-10-17", + "Statement": [ + { + "Effect": "Allow", + "Action": "*, + "Resource": "*", + } + ] + }`, + }}, + want: nil, + wantErr: true, + }, + { + name: "NoPolicy#4", + args: args{[]string{}}, + want: []string{}, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := mergePolicyActions(tt.args.policyDocs) + if (err != nil) != tt.wantErr { + t.Errorf("mashPolices() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("mashPolices() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_getNetIAMRolePermissions(t *testing.T) { + // sess, _ := NewAuthenticatedSession("us-east-1") + // client := NewClient(sess) + // result, err := client.getNetIAMRolePermissions("111111111111_SplunkRole") + // if err != nil { + // log.Println(err) + // } + // log.Println(result, len(result)) + // t.Fail() + type args struct { + roleName string + } + tests := []struct { + name string + args args + mockedListRolePoliciesResponse *iam.ListRolePoliciesOutput + mockedGetRolePolicyResponse *iam.GetRolePolicyOutput + mockedListAttachedRolePoliciesResponse *iam.ListAttachedRolePoliciesOutput + mockedGetPolicyResponse *iam.GetPolicyOutput + mockedGetPolicyVersionResponse *iam.GetPolicyVersionOutput + want []string + wantErr bool + }{ + { + name: "simpleRolewithAttachedPolicy#1", + args: args{roleName: "simpleRolewithAttachedPolicy"}, + mockedListRolePoliciesResponse: &iam.ListRolePoliciesOutput{}, + mockedGetRolePolicyResponse: &iam.GetRolePolicyOutput{}, + mockedListAttachedRolePoliciesResponse: &iam.ListAttachedRolePoliciesOutput{ + AttachedPolicies: []*iam.AttachedPolicy{ + {PolicyArn: aws.String("arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"), PolicyName: aws.String("AmazonECSTaskExecutionRolePolicy")}, + }, + }, + mockedGetPolicyResponse: &iam.GetPolicyOutput{ + Policy: &iam.Policy{ + Arn: aws.String("arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"), + PolicyName: aws.String("AmazonECSTaskExecutionRolePolicy"), + DefaultVersionId: aws.String("v1"), + }, + }, + mockedGetPolicyVersionResponse: &iam.GetPolicyVersionOutput{PolicyVersion: &iam.PolicyVersion{ + Document: aws.String("%7B%0A%20%20%22Version%22%3A%20%222012-10-17%22%2C%0A%20%20%22Statement%22%3A%20%5B%0A%20%20%20%20%7B%0A%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0A%20%20%20%20%20%20%22Action%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%22ecr%3AGetAuthorizationToken%22%2C%0A%20%20%20%20%20%20%20%20%22ecr%3ABatchCheckLayerAvailability%22%2C%0A%20%20%20%20%20%20%20%20%22ecr%3AGetDownloadUrlForLayer%22%2C%0A%20%20%20%20%20%20%20%20%22ecr%3ABatchGetImage%22%2C%0A%20%20%20%20%20%20%20%20%22logs%3ACreateLogStream%22%2C%0A%20%20%20%20%20%20%20%20%22logs%3APutLogEvents%22%0A%20%20%20%20%20%20%5D%2C%0A%20%20%20%20%20%20%22Resource%22%3A%20%22%2A%22%0A%20%20%20%20%7D%0A%20%20%5D%0A%7D"), + VersionId: aws.String("v1"), + }}, + want: []string{ + "ecr:GetAuthorizationToken", + "ecr:BatchCheckLayerAvailability", + "ecr:GetDownloadUrlForLayer", + "ecr:BatchGetImage", + "logs:CreateLogStream", + "logs:PutLogEvents", + }, + wantErr: false, + }, + { + name: "simpleRolewithInlinePolicy#2", + args: args{roleName: "simpleRolewithInlinePolicy"}, + mockedListRolePoliciesResponse: &iam.ListRolePoliciesOutput{PolicyNames: []*string{aws.String("S3Policy")}}, + mockedGetRolePolicyResponse: &iam.GetRolePolicyOutput{ + PolicyDocument: aws.String("%7B%0A%20%20%20%20%22Version%22%3A%20%222012-10-17%22%2C%0A%20%20%20%20%22Statement%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Action%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3APutObject%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3AListBucket%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3AGetObject%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3AGetBucketAcl%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3ADeleteObject%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%5D%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Resource%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22arn%3Aaws%3As3%3A%3A%3Aoid-stage-dsfds%2F%2A%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22arn%3Aaws%3As3%3A%3A%3Aoid-stage-sdfdsf%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%5D%0A%20%20%20%20%20%20%20%20%7D%2C%0A%20%20%20%20%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Action%22%3A%20%22events%3APutEvents%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Resource%22%3A%20%22%2A%22%0A%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%5D%0A%7D"), + PolicyName: aws.String("S3Policy"), + RoleName: aws.String("simpleRolewithInlinePolicy"), + }, + mockedListAttachedRolePoliciesResponse: &iam.ListAttachedRolePoliciesOutput{}, + mockedGetPolicyResponse: &iam.GetPolicyOutput{}, + mockedGetPolicyVersionResponse: &iam.GetPolicyVersionOutput{}, + want: []string{ + "s3:PutObject", + "s3:ListBucket", + "s3:GetObject", + "s3:GetBucketAcl", + "s3:DeleteObject", + "events:PutEvents", + }, + wantErr: false, + }, + { + name: "RolewithBothInlineAndAttachedPolicy#3", + args: args{roleName: "simpleRolewithInlinePolicy"}, + mockedListRolePoliciesResponse: &iam.ListRolePoliciesOutput{PolicyNames: []*string{aws.String("S3Policy")}}, + mockedGetRolePolicyResponse: &iam.GetRolePolicyOutput{ + PolicyDocument: aws.String("%7B%0A%20%20%20%20%22Version%22%3A%20%222012-10-17%22%2C%0A%20%20%20%20%22Statement%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Action%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3APutObject%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3AListBucket%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3AGetObject%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3AGetBucketAcl%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22s3%3ADeleteObject%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%5D%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Resource%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22arn%3Aaws%3As3%3A%3A%3Aoid-stage-dsfds%2F%2A%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22arn%3Aaws%3As3%3A%3A%3Aoid-stage-sdfdsf%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%5D%0A%20%20%20%20%20%20%20%20%7D%2C%0A%20%20%20%20%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Sid%22%3A%20%22%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Action%22%3A%20%22events%3APutEvents%22%2C%0A%20%20%20%20%20%20%20%20%20%20%20%20%22Resource%22%3A%20%22%2A%22%0A%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%5D%0A%7D"), + PolicyName: aws.String("S3Policy"), + RoleName: aws.String("simpleRolewithInlinePolicy"), + }, + mockedListAttachedRolePoliciesResponse: &iam.ListAttachedRolePoliciesOutput{ + AttachedPolicies: []*iam.AttachedPolicy{ + {PolicyArn: aws.String("arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"), PolicyName: aws.String("AmazonECSTaskExecutionRolePolicy")}, + }, + }, + mockedGetPolicyResponse: &iam.GetPolicyOutput{ + Policy: &iam.Policy{ + Arn: aws.String("arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"), + PolicyName: aws.String("AmazonECSTaskExecutionRolePolicy"), + DefaultVersionId: aws.String("v1"), + }, + }, + mockedGetPolicyVersionResponse: &iam.GetPolicyVersionOutput{PolicyVersion: &iam.PolicyVersion{ + Document: aws.String("%7B%0A%20%20%22Version%22%3A%20%222012-10-17%22%2C%0A%20%20%22Statement%22%3A%20%5B%0A%20%20%20%20%7B%0A%20%20%20%20%20%20%22Effect%22%3A%20%22Allow%22%2C%0A%20%20%20%20%20%20%22Action%22%3A%20%5B%0A%20%20%20%20%20%20%20%20%22ecr%3AGetAuthorizationToken%22%2C%0A%20%20%20%20%20%20%20%20%22ecr%3ABatchCheckLayerAvailability%22%2C%0A%20%20%20%20%20%20%20%20%22ecr%3AGetDownloadUrlForLayer%22%2C%0A%20%20%20%20%20%20%20%20%22ecr%3ABatchGetImage%22%2C%0A%20%20%20%20%20%20%20%20%22logs%3ACreateLogStream%22%2C%0A%20%20%20%20%20%20%20%20%22logs%3APutLogEvents%22%0A%20%20%20%20%20%20%5D%2C%0A%20%20%20%20%20%20%22Resource%22%3A%20%22%2A%22%0A%20%20%20%20%7D%0A%20%20%5D%0A%7D"), + VersionId: aws.String("v1"), + }}, + want: []string{ + "s3:PutObject", + "s3:ListBucket", + "s3:GetObject", + "s3:GetBucketAcl", + "s3:DeleteObject", + "events:PutEvents", + "ecr:GetAuthorizationToken", + "ecr:BatchCheckLayerAvailability", + "ecr:GetDownloadUrlForLayer", + "ecr:BatchGetImage", + "logs:CreateLogStream", + "logs:PutLogEvents", + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockIAMAPI := mocks.NewMockIAMAPI(mockCtrl) + mockIAMAPI.EXPECT().ListRolePolicies(&iam.ListRolePoliciesInput{RoleName: aws.String(tt.args.roleName)}).Return(tt.mockedListRolePoliciesResponse, nil) + for _, v := range tt.mockedListRolePoliciesResponse.PolicyNames { + mockIAMAPI.EXPECT().GetRolePolicy(&iam.GetRolePolicyInput{PolicyName: v, RoleName: aws.String(tt.args.roleName)}).Return(tt.mockedGetRolePolicyResponse, nil).AnyTimes() + } + mockIAMAPI.EXPECT().ListAttachedRolePolicies(&iam.ListAttachedRolePoliciesInput{RoleName: aws.String(tt.args.roleName)}).Return(tt.mockedListAttachedRolePoliciesResponse, nil) + for _, v := range tt.mockedListAttachedRolePoliciesResponse.AttachedPolicies { + mockIAMAPI.EXPECT().GetPolicy(&iam.GetPolicyInput{PolicyArn: v.PolicyArn}).Return(tt.mockedGetPolicyResponse, nil).AnyTimes() + mockIAMAPI.EXPECT().GetPolicyVersion(&iam.GetPolicyVersionInput{PolicyArn: v.PolicyArn, VersionId: tt.mockedGetPolicyResponse.Policy.DefaultVersionId}).Return(tt.mockedGetPolicyVersionResponse, nil).AnyTimes() + } + client := &Client{ + IAM: mockIAMAPI, + } + got, err := client.getNetIAMRolePermissions(tt.args.roleName) + if (err != nil) != tt.wantErr { + t.Errorf("getNetIAMRolePermissions() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("getNetIAMRolePermissions() = %v, want %v", got, tt.want) + } + }) + } +} + +// func TestClient_GetNetIAMPermissionsForRoles(t *testing.T) { +// sess, _ := NewAuthenticatedSession("us-east-1") +// client := NewClient(sess) +// result, err := client.GetNetIAMPermissionsForRoles([]string{"arn:aws:iam::111111111111:role/cluster-autoscaler-greencherry-dev", +// "arn:aws:iam::111111111111:role/cluster-autoscaler-greencherry-okra", +// "arn:aws:iam::111111111111:role/cluster-autoscaler-greencherry-stage", +// "arn:aws:iam::111111111111:role/cognito-access-policy-dce", +// "arn:aws:iam::111111111111:role/config-server-greencherry-dev", +// "arn:aws:iam::111111111111:role/config-server-greencherry-okra", +// "arn:aws:iam::111111111111:role/config-server-greencherry-stage", +// "arn:aws:iam::111111111111:role/configuration-recorder-role", +// "arn:aws:iam::111111111111:role/db-utility-greencherry-dev", +// "arn:aws:iam::111111111111:role/db-utility-greencherry-okra", +// "arn:aws:iam::111111111111:role/db-utility-greencherry-stage", +// "arn:aws:iam::111111111111:role/dev-exodos-role", +// "arn:aws:iam::111111111111:role/dev-exodos-secret-updater-role", +// "arn:aws:iam::111111111111:role/ecs_task_execution_role_name_dev", +// "arn:aws:iam::111111111111:role/ecs_task_execution_role_name_stage", +// }) +// if err != nil { +// log.Println(err) +// } +// log.Println(result, len(result)) +// t.Fail() +// } + +func Test_runInBatches(t *testing.T) { + type args struct { + //targetFunc func(string) + targetSlice []string + limit int + } + tests := []struct { + name string + args args + want []string + }{ + { + name: "#1", + args: args{ + targetSlice: []string{"a", "b", "c", "d"}, + limit: 10, + }, + want: []string{"aa", "ba", "ca", "da"}, + }, + { + name: "#2", + args: args{ + targetSlice: []string{}, + limit: 10, + }, + want: []string{}, + }, + { + name: "#3", + args: args{ + targetSlice: []string{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23"}, + limit: 10, + }, + want: []string{"13a", "14a", "15a", "16a", "17a", "18a", "19a", "20a", "21a", "22a", "23a", "1a", "2a", "3a", "4a", "5a", "6a", "7a", "8a", "9a", "10a", "11a", "12a"}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + output := make(chan string, len(tt.args.targetSlice)) + runInBatches(func(v string) { + output <- v + "a" + }, tt.args.targetSlice, tt.args.limit) + results := make([]string, 0) + // close chanel + close(output) + for v := range output { + results = append(results, v) + } + if !assert.ElementsMatch(t, results, tt.want) { + t.Errorf("runInBatches() = %v, want %v", results, tt.want) + } + }) + } + +} diff --git a/pkg/aws/inspector.go b/pkg/aws/inspector.go new file mode 100644 index 0000000..fc5b3b6 --- /dev/null +++ b/pkg/aws/inspector.go @@ -0,0 +1,88 @@ +package aws + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/inspector" +) + +// InspectorSVC is a wrapper for Inspector API calls +type InspectorSVC interface { + GenerateReport(assessmentRunArn string, reportFormat string, reportType string) (string, error) + GetResourceGroupTags(assessmentTargetArn string) (map[string]string, error) + GetMostRecentAssessmentRunInfo() ([]map[string]string, error) +} + +// GenerateReport generates an inspector report for a given assessment run ARN in either PDF or HTML and returns the URL +func (client *Client) GenerateReport(assessmentRunArn string, reportFormat string, reportType string) (string, error) { + input := &inspector.GetAssessmentReportInput{ + AssessmentRunArn: aws.String(assessmentRunArn), + ReportFileFormat: aws.String(reportFormat), + ReportType: aws.String(reportType), + } + + report, err := client.Inspector.GetAssessmentReport(input) + if err != nil { + return "", err + } + + return aws.StringValue(report.Url), nil +} + +// GetResourceGroupTags returns the resource group tags for a given assessment target ARN +func (client *Client) GetResourceGroupTags(assessmentTargetArn string) (map[string]string, error) { + targetInfo, err := client.Inspector.DescribeAssessmentTargets( + &inspector.DescribeAssessmentTargetsInput{ + AssessmentTargetArns: []*string{aws.String(assessmentTargetArn)}, + }, + ) + if err != nil { + return nil, err + } + + resourceGroupInfo, err := client.Inspector.DescribeResourceGroups( + &inspector.DescribeResourceGroupsInput{ + ResourceGroupArns: []*string{targetInfo.AssessmentTargets[0].ResourceGroupArn}, + }, + ) + if err != nil { + return nil, err + } + + tags := make(map[string]string, len(resourceGroupInfo.ResourceGroups[0].Tags)) + for _, tag := range resourceGroupInfo.ResourceGroups[0].Tags { + tags[aws.StringValue(tag.Key)] = aws.StringValue(tag.Value) + } + + return tags, nil +} + +// GetMostRecentAssessmentRunInfo returns the most recent assessment run and target group ARNs for each template +func (client *Client) GetMostRecentAssessmentRunInfo() ([]map[string]string, error) { + templates, err := client.Inspector.ListAssessmentTemplates(&inspector.ListAssessmentTemplatesInput{}) + if err != nil { + return nil, err + } + + templateInfo, err := client.Inspector.DescribeAssessmentTemplates( + &inspector.DescribeAssessmentTemplatesInput{ + AssessmentTemplateArns: templates.AssessmentTemplateArns, + }, + ) + if err != nil { + return nil, err + } + + assessmentRunInfo := make([]map[string]string, 0) + for _, template := range templateInfo.AssessmentTemplates { + // Only return information on assessment templates that have been run + if *template.LastAssessmentRunArn != "" { + assessmentRunInfo = append(assessmentRunInfo, map[string]string{ + "templateName": aws.StringValue(template.Name), + "targetArn": aws.StringValue(template.AssessmentTargetArn), + "arn": aws.StringValue(template.LastAssessmentRunArn), + }) + } + } + + return assessmentRunInfo, nil +} diff --git a/pkg/aws/inspector_test.go b/pkg/aws/inspector_test.go new file mode 100644 index 0000000..6646c89 --- /dev/null +++ b/pkg/aws/inspector_test.go @@ -0,0 +1,239 @@ +package aws + +import ( + "errors" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/inspector" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/Optum/cloudig/pkg/mocks" +) + +func TestGetResourceGroupTags(t *testing.T) { + type args struct { + assessmentTargetArn string + } + testCases := []struct { + name string + input args + describeAssessmentTargetsAPIResponse *inspector.DescribeAssessmentTargetsOutput + describeResourceGroupsAPIResponse *inspector.DescribeResourceGroupsOutput + expectedOutput map[string]string + expectedError error + }{ + { + name: "Return expected resource group tags", + input: args{ + assessmentTargetArn: "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF", + }, + describeAssessmentTargetsAPIResponse: &inspector.DescribeAssessmentTargetsOutput{ + AssessmentTargets: []*inspector.AssessmentTarget{ + { + Arn: aws.String("arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF"), + Name: aws.String("k8s_cluster"), + ResourceGroupArn: aws.String("arn:aws:inspector:us-east-1:111111111111:resourcegroup/0-GFvUHPhY"), + }, + }, + }, + describeResourceGroupsAPIResponse: &inspector.DescribeResourceGroupsOutput{ + ResourceGroups: []*inspector.ResourceGroup{ + { + Arn: aws.String("arn:aws:inspector:us-east-1:111111111111:resourcegroup/0-GFvUHPhY"), + Tags: []*inspector.ResourceGroupTag{ + { + Key: aws.String("dig-owned"), + Value: aws.String("True"), + }, + { + Key: aws.String("aws_inspector"), + Value: aws.String("true"), + }, + { + Key: aws.String("terraform"), + Value: aws.String("True"), + }, + }, + }, + }, + }, + expectedOutput: map[string]string{ + "dig-owned": "True", + "aws_inspector": "true", + "terraform": "True", + }, + expectedError: nil, + }, + { + name: "Error response", + input: args{ + assessmentTargetArn: "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF", + }, + expectedOutput: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockInspectorAPI := mocks.NewMockInspectorAPI(mockCtrl) + mockInspectorAPI.EXPECT().DescribeAssessmentTargets(gomock.Any()).Return(tc.describeAssessmentTargetsAPIResponse, tc.expectedError).MaxTimes(1) + mockInspectorAPI.EXPECT().DescribeResourceGroups(gomock.Any()).Return(tc.describeResourceGroupsAPIResponse, tc.expectedError).MaxTimes(1) + + client := &Client{ + Inspector: mockInspectorAPI, + } + + output, err := client.GetResourceGroupTags(tc.input.assessmentTargetArn) + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} +func TestGetMostRecentAssessmentRunInfo(t *testing.T) { + testCases := []struct { + name string + listAssessmentTemplatesAPIResponse *inspector.ListAssessmentTemplatesOutput + describeAssessmentTemplatesAPIResponse *inspector.DescribeAssessmentTemplatesOutput + expectedOutput []map[string]string + expectedError error + }{ + { + name: "Get assessment template info correctly", + listAssessmentTemplatesAPIResponse: &inspector.ListAssessmentTemplatesOutput{ + AssessmentTemplateArns: aws.StringSlice([]string{"arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW/template/0-qLRbgV2x", "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF/template/0-eLtPoQf3"}), + }, + describeAssessmentTemplatesAPIResponse: &inspector.DescribeAssessmentTemplatesOutput{ + AssessmentTemplates: []*inspector.AssessmentTemplate{ + { + Arn: aws.String("arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW/template/0-qLRbgV2x"), + AssessmentRunCount: aws.Int64(1), + AssessmentTargetArn: aws.String("arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW"), + LastAssessmentRunArn: aws.String("arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW/template/0-qLRbgV2x/run/0-gKfIrDIK"), + Name: aws.String("test-once-dev"), + RulesPackageArns: aws.StringSlice([]string{"arn:aws:inspector:us-east-1:222222222222:rulespackage/0-gEjTy7T7", "arn:aws:inspector:us-east-1:222222222222:rulespackage/0-rExsr2X8", "arn:aws:inspector:us-east-1:222222222222:rulespackage/0-R01qwB5Q"}), + }, + { + Arn: aws.String("arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF/template/0-eLtPoQf3"), + AssessmentRunCount: aws.Int64(23), + AssessmentTargetArn: aws.String("arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF"), + LastAssessmentRunArn: aws.String("arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF/template/0-eLtPoQf3/run/0-8Wf02Drc"), + Name: aws.String("k8s_weekly_scan"), + RulesPackageArns: aws.StringSlice([]string{ + "arn:aws:inspector:us-east-1:222222222222:rulespackage/0-gEjTy7T7", + "arn:aws:inspector:us-east-1:222222222222:rulespackage/0-rExsr2X8", + "arn:aws:inspector:us-east-1:222222222222:rulespackage/0-PmNV0Tcd", + "arn:aws:inspector:us-east-1:222222222222:rulespackage/0-R01qwB5Q", + }), + }, + }, + }, + expectedOutput: []map[string]string{ + { + "templateName": "test-once-dev", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW/template/0-qLRbgV2x/run/0-gKfIrDIK", + }, + { + "templateName": "k8s_weekly_scan", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF/template/0-eLtPoQf3/run/0-8Wf02Drc", + }, + }, + expectedError: nil, + }, + { + name: "Error response", + expectedOutput: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockInspectorAPI := mocks.NewMockInspectorAPI(mockCtrl) + mockInspectorAPI.EXPECT().ListAssessmentTemplates(&inspector.ListAssessmentTemplatesInput{}).Return(tc.listAssessmentTemplatesAPIResponse, tc.expectedError).MaxTimes(1) + mockInspectorAPI.EXPECT().DescribeAssessmentTemplates(gomock.Any()).Return(tc.describeAssessmentTemplatesAPIResponse, tc.expectedError).MaxTimes(1) + + client := &Client{ + Inspector: mockInspectorAPI, + } + + output, err := client.GetMostRecentAssessmentRunInfo() + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestGenerateReport(t *testing.T) { + type args struct { + assessmentRunArn string + reportFormat string + reportType string + } + testCases := []struct { + name string + input *args + apiResponse *inspector.GetAssessmentReportOutput + expectedOutput string + expectedError error + }{ + { + name: "Get HTML Inspector report", + input: &args{ + assessmentRunArn: "arn:aws:inspector:us-east-1:012345678910:target/0-E70Tx7xF/template/0-rzwwKHOj/run/0-YIoTczu6", + reportFormat: "HTML", + reportType: "FULL", + }, + apiResponse: &inspector.GetAssessmentReportOutput{ + Status: aws.String("COMPLETED"), + Url: aws.String("https://inspector-temp-reports-prod-us-east-1.s3.amazonaws.com/arn%3Aaws%3Ainspector%3Aus-east-1%3A012345678910%3Atarget/0-E70Tx7xF/template/0-rzwwKHOj/run/0-YIoTczu6-full-report.html?response-content-type=text%2Fhtml&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20200102T141203Z&X-Amz-SignedHeaders=host&X-Amz-Expires=900&X-Amz-Credential=AKIAUTGOFMZ6SBI6BDMH%2F20200102%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Signature=889649d423f4158344daf6a4ee28cee000e9f52dda08c71beaf0b6a8226e6625"), + }, + expectedOutput: "https://inspector-temp-reports-prod-us-east-1.s3.amazonaws.com/arn%3Aaws%3Ainspector%3Aus-east-1%3A012345678910%3Atarget/0-E70Tx7xF/template/0-rzwwKHOj/run/0-YIoTczu6-full-report.html?response-content-type=text%2Fhtml&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20200102T141203Z&X-Amz-SignedHeaders=host&X-Amz-Expires=900&X-Amz-Credential=AKIAUTGOFMZ6SBI6BDMH%2F20200102%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Signature=889649d423f4158344daf6a4ee28cee000e9f52dda08c71beaf0b6a8226e6625", + expectedError: nil, + }, + { + name: "Error response", + input: &args{ + assessmentRunArn: "arn:aws:inspector:us-east-1:012345678910:target/0-E70Tx7xF/template/0-rzwwKHOj/run/0-YIoTczu6", + reportFormat: "HTML", + reportType: "FULL", + }, + apiResponse: &inspector.GetAssessmentReportOutput{}, + expectedOutput: "", + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockInspectorAPI := mocks.NewMockInspectorAPI(mockCtrl) + mockInspectorAPI.EXPECT().GetAssessmentReport( + &inspector.GetAssessmentReportInput{ + AssessmentRunArn: aws.String(tc.input.assessmentRunArn), + ReportFileFormat: aws.String(tc.input.reportFormat), + ReportType: aws.String(tc.input.reportType), + }, + ).Return(tc.apiResponse, tc.expectedError) + client := &Client{ + Inspector: mockInspectorAPI, + } + + output, err := client.GenerateReport(tc.input.assessmentRunArn, tc.input.reportFormat, tc.input.reportType) + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} diff --git a/pkg/aws/sts.go b/pkg/aws/sts.go new file mode 100644 index 0000000..629b101 --- /dev/null +++ b/pkg/aws/sts.go @@ -0,0 +1,19 @@ +package aws + +import ( + "github.com/aws/aws-sdk-go/service/sts" +) + +// STSSVC is a wrapper for STS API calls +type STSSVC interface { + GetAccountID() (string, error) +} + +// GetAccountID returns the AccountID associated with the current session +func (client *Client) GetAccountID() (string, error) { + result, err := client.STS.GetCallerIdentity(&sts.GetCallerIdentityInput{}) + if err != nil { + return "", err + } + return *result.Account, nil +} diff --git a/pkg/aws/sts_test.go b/pkg/aws/sts_test.go new file mode 100644 index 0000000..f806843 --- /dev/null +++ b/pkg/aws/sts_test.go @@ -0,0 +1,57 @@ +package aws + +import ( + "errors" + "testing" + + "github.com/Optum/cloudig/pkg/mocks" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/sts" +) + +func TestGetAccountID(t *testing.T) { + testCases := []struct { + name string + apiResponse *sts.GetCallerIdentityOutput + expectedOutput string + expectedError error + }{ + { + name: "Return Account ID", + apiResponse: &sts.GetCallerIdentityOutput{ + Account: aws.String("012345678910"), + Arn: aws.String("arn:aws:sts::012345678910:assumed-role/AWS_012345678910_ReadOnly/test@gmail.com"), + UserId: aws.String("AROAIU4J2NPCGYXQIOPMQ:test@gmail.com"), + }, + expectedOutput: "012345678910", + expectedError: nil, + }, + { + name: "Return error", + apiResponse: &sts.GetCallerIdentityOutput{}, + expectedOutput: "", + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockSTSAPI := mocks.NewMockSTSAPI(mockCtrl) + mockSTSAPI.EXPECT().GetCallerIdentity(&sts.GetCallerIdentityInput{}).Return(tc.apiResponse, tc.expectedError) + client := &Client{ + STS: mockSTSAPI, + } + + output, err := client.GetAccountID() + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} diff --git a/pkg/aws/trustedadvisor.go b/pkg/aws/trustedadvisor.go new file mode 100644 index 0000000..6ff1a0f --- /dev/null +++ b/pkg/aws/trustedadvisor.go @@ -0,0 +1,37 @@ +package aws + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/support" +) + +// TrustedAdvisorSVC is a wrapper for Support API calls related to TrustedAdvisor +type TrustedAdvisorSVC interface { + GetFailingTrustedAdvisorCheckResults() (map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult, error) +} + +// GetFailingTrustedAdvisorCheckResults returns all failing trusted advisor checks with detailed results +func (client *Client) GetFailingTrustedAdvisorCheckResults() (map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult, error) { + language := "en" + result := make(map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult) + allChecksOutput, err := client.TrustedAdvisor.DescribeTrustedAdvisorChecks(&support.DescribeTrustedAdvisorChecksInput{Language: aws.String(language)}) + if err != nil { + return nil, err + } + + for _, check := range allChecksOutput.Checks { + checkResultOutput, err := client.TrustedAdvisor.DescribeTrustedAdvisorCheckResult( + &support.DescribeTrustedAdvisorCheckResultInput{ + CheckId: check.Id, + Language: aws.String(language)}, + ) + if err != nil { + return nil, err + } + // no constants available + if aws.StringValue(checkResultOutput.Result.Status) != "not_available" && aws.StringValue(checkResultOutput.Result.Status) != "ok" { + result[check] = checkResultOutput.Result + } + } + return result, nil +} diff --git a/pkg/aws/trustedadvisor_test.go b/pkg/aws/trustedadvisor_test.go new file mode 100644 index 0000000..1b353aa --- /dev/null +++ b/pkg/aws/trustedadvisor_test.go @@ -0,0 +1,213 @@ +package aws + +import ( + "errors" + "reflect" + "testing" + + "github.com/Optum/cloudig/pkg/mocks" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/support" +) + +func TestGetFailingTrustedAdvisorCheckResults(t *testing.T) { + testCases := []struct { + name string + mockDescribeTrustedAdvisorChecksResponse *support.DescribeTrustedAdvisorChecksOutput + mockDescribeTrustedAdvisorCheckResultResponse []*support.DescribeTrustedAdvisorCheckResultOutput + mockDescribeTrustedAdvisorChecksError error + mockDescribeTrustedAdvisorCheckResultError error + expectedOutput map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult + expectedError error + }{ + { + name: "Get failing results for a TrustedAdvisor checks", + mockDescribeTrustedAdvisorChecksResponse: &support.DescribeTrustedAdvisorChecksOutput{ + Checks: []*support.TrustedAdvisorCheckDescription{ + { + Category: aws.String("cost_optimizing"), + Description: aws.String("Checks for Elastic IP addresses (EIPs) that are not associated with a running Amazon Elastic Compute Cloud (Amazon EC2) instance. EIPs are static IP addresses designed for dynamic cloud computing. Unlike traditional static IP addresses, EIPs can mask the failure of an instance or Availability Zone by remapping a public IP address to another instance in your account. A nominal charge is imposed for an EIP that is not associated with a running instance.
\n
\nAlert Criteria
\nYellow: An allocated Elastic IP address (EIP) is not associated with a running Amazon EC2 instance.
\n
\nRecommended Action
\nAssociate the EIP with a running active instance, or release the unassociated EIP. For more information, see Associating an Elastic IP Address with a Different Running Instance and Releasing an Elastic IP Address.
\n
\nAdditional Resources
\nElastic IP Addresses"), + Id: aws.String("Z4AUBRNSmz"), + Metadata: aws.StringSlice([]string{"Status", "Region", "IP Address"}), + Name: aws.String("Unassociated Elastic IP Addresses"), + }, + { + Category: aws.String("security"), + Description: aws.String("Checks security groups for rules that allow unrestricted access (0.0.0.0/0) to specific ports. Unrestricted access increases opportunities for malicious activity (hacking, denial-of-service attacks, loss of data). The ports with highest risk are flagged red, and those with less risk are flagged yellow. Ports flagged green are typically used by applications that require unrestricted access, such as HTTP and SMTP.\n
\nIf you have intentionally configured your security groups in this manner, we recommend using additional security measures to secure your infrastructure (such as IP tables).\n
\n
\nAlert Criteria\n
\nGreen: Access to port 80, 25, 443, or 465 is unrestricted.
\nRed: Access to port 20, 21, 1433, 1434, 3306, 3389, 4333, 5432, or 5500 is unrestricted.
\nYellow: Access to any other port is unrestricted.\n
\n
\nRecommended Action\n
\nRestrict access to only those IP addresses that require it. To restrict access to a specific IP address, set the suffix to /32 (for example, 192.0.2.10/32). Be sure to delete overly permissive rules after creating rules that are more restrictive.
\n
\nAdditional Resources
\nAmazon EC2 Security Groups
\nList of TCP and UDP port numbers (Wikipedia)
\nClassless Inter-Domain Routing (Wikipedia)"), + Id: aws.String("HCP4007jGY"), + Metadata: aws.StringSlice([]string{ + "Region", + "Security Group Name", + "Security Group ID", + "Protocol", + }), + Name: aws.String("Security Groups - Specific Ports Unrestricted"), + }, + }, + }, + mockDescribeTrustedAdvisorCheckResultResponse: []*support.DescribeTrustedAdvisorCheckResultOutput{ + { + Result: &support.TrustedAdvisorCheckResult{ + CheckId: aws.String("Z4AUBRNSmz"), + ResourcesSummary: &support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(0), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(7), + ResourcesSuppressed: aws.Int64(0), + }, + Status: aws.String("ok"), + }, + }, + { + Result: &support.TrustedAdvisorCheckResult{ + CheckId: aws.String("HCP4007jGY"), + ResourcesSummary: &support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(0), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(3), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []*support.TrustedAdvisorResourceDetail{ + { + IsSuppressed: aws.Bool(false), + Metadata: aws.StringSlice([]string{ + "Yellow", + "us-east-1", + "My-test-SG", + "sg-passmeifyoucan", + "tcp", + }, + ), + Region: aws.String("us-east-1"), + ResourceId: aws.String("QtCJL9NshMFH8AHUBLdX_fvrnAOPSTpR-hzxk0YU4oI"), + Status: aws.String("warning"), + }, + { + IsSuppressed: aws.Bool(false), + Metadata: aws.StringSlice([]string{ + "Yellow", + "us-east-1", + "My-test-SG", + "sg-allarewelcome", + "udp"}, + ), + Region: aws.String("us-east-1"), + ResourceId: aws.String("M1nMGLq-DqEbS0jbaObJ1IXucGlQ_shfjksdkflsdfd"), + Status: aws.String("warning"), + }, + }, + Status: aws.String("warning"), + }, + }, + }, + expectedOutput: map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult{ + { + Category: aws.String("security"), + Description: aws.String("Checks security groups for rules that allow unrestricted access (0.0.0.0/0) to specific ports. Unrestricted access increases opportunities for malicious activity (hacking, denial-of-service attacks, loss of data). The ports with highest risk are flagged red, and those with less risk are flagged yellow. Ports flagged green are typically used by applications that require unrestricted access, such as HTTP and SMTP.\n
\nIf you have intentionally configured your security groups in this manner, we recommend using additional security measures to secure your infrastructure (such as IP tables).\n
\n
\nAlert Criteria\n
\nGreen: Access to port 80, 25, 443, or 465 is unrestricted.
\nRed: Access to port 20, 21, 1433, 1434, 3306, 3389, 4333, 5432, or 5500 is unrestricted.
\nYellow: Access to any other port is unrestricted.\n
\n
\nRecommended Action\n
\nRestrict access to only those IP addresses that require it. To restrict access to a specific IP address, set the suffix to /32 (for example, 192.0.2.10/32). Be sure to delete overly permissive rules after creating rules that are more restrictive.
\n
\nAdditional Resources
\nAmazon EC2 Security Groups
\nList of TCP and UDP port numbers (Wikipedia)
\nClassless Inter-Domain Routing (Wikipedia)"), + Id: aws.String("HCP4007jGY"), + Metadata: aws.StringSlice([]string{ + "Region", + "Security Group Name", + "Security Group ID", + "Protocol", + }), + Name: aws.String("Security Groups - Specific Ports Unrestricted"), + }: { + CheckId: aws.String("HCP4007jGY"), + ResourcesSummary: &support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(0), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(3), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []*support.TrustedAdvisorResourceDetail{ + { + IsSuppressed: aws.Bool(false), + Metadata: aws.StringSlice([]string{ + "Yellow", + "us-east-1", + "My-test-SG", + "sg-passmeifyoucan", + "tcp", + }, + ), + Region: aws.String("us-east-1"), + ResourceId: aws.String("QtCJL9NshMFH8AHUBLdX_fvrnAOPSTpR-hzxk0YU4oI"), + Status: aws.String("warning"), + }, + { + IsSuppressed: aws.Bool(false), + Metadata: aws.StringSlice([]string{ + "Yellow", + "us-east-1", + "My-test-SG", + "sg-allarewelcome", + "udp"}, + ), + Region: aws.String("us-east-1"), + ResourceId: aws.String("M1nMGLq-DqEbS0jbaObJ1IXucGlQ_shfjksdkflsdfd"), + Status: aws.String("warning"), + }, + }, + Status: aws.String("warning"), + }, + }, + }, + { + name: "error from DescribeTrustedAdvisorChecks", + mockDescribeTrustedAdvisorChecksResponse: nil, + mockDescribeTrustedAdvisorChecksError: errors.New("bad error"), + expectedOutput: nil, + expectedError: errors.New("bad error"), + }, + { + name: "error from DescribeTrustedAdvisorCheckResult", + mockDescribeTrustedAdvisorChecksResponse: &support.DescribeTrustedAdvisorChecksOutput{ + Checks: []*support.TrustedAdvisorCheckDescription{ + { + Category: aws.String("cost_optimizing"), + Description: aws.String("Checks for Elastic IP addresses (EIPs) that are not associated with a running Amazon Elastic Compute Cloud (Amazon EC2) instance. EIPs are static IP addresses designed for dynamic cloud computing. Unlike traditional static IP addresses, EIPs can mask the failure of an instance or Availability Zone by remapping a public IP address to another instance in your account. A nominal charge is imposed for an EIP that is not associated with a running instance.
\n
\nAlert Criteria
\nYellow: An allocated Elastic IP address (EIP) is not associated with a running Amazon EC2 instance.
\n
\nRecommended Action
\nAssociate the EIP with a running active instance, or release the unassociated EIP. For more information, see Associating an Elastic IP Address with a Different Running Instance and Releasing an Elastic IP Address.
\n
\nAdditional Resources
\nElastic IP Addresses"), + Id: aws.String("Z4AUBRNSmz"), + Metadata: aws.StringSlice([]string{"Status", "Region", "IP Address"}), + Name: aws.String("Unassociated Elastic IP Addresses"), + }, + }, + }, + mockDescribeTrustedAdvisorCheckResultResponse: nil, + mockDescribeTrustedAdvisorCheckResultError: errors.New("bad error"), + expectedOutput: nil, + expectedError: errors.New("bad error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockSupportAPI := mocks.NewMockSupportAPI(mockCtrl) + + mockSupportAPI.EXPECT().DescribeTrustedAdvisorChecks(gomock.Any()).Return(tc.mockDescribeTrustedAdvisorChecksResponse, tc.mockDescribeTrustedAdvisorChecksError).MaxTimes(1) + if tc.mockDescribeTrustedAdvisorChecksResponse != nil && + tc.mockDescribeTrustedAdvisorCheckResultResponse != nil && + len(tc.mockDescribeTrustedAdvisorChecksResponse.Checks) > 0 { + for i := range tc.mockDescribeTrustedAdvisorChecksResponse.Checks { + mockSupportAPI.EXPECT().DescribeTrustedAdvisorCheckResult(gomock.Any()).Return(tc.mockDescribeTrustedAdvisorCheckResultResponse[i], tc.mockDescribeTrustedAdvisorCheckResultError).MaxTimes(1) + } + } else { + mockSupportAPI.EXPECT().DescribeTrustedAdvisorCheckResult(gomock.Any()).Return(nil, tc.mockDescribeTrustedAdvisorCheckResultError).MaxTimes(1) + } + client := &Client{ + TrustedAdvisor: mockSupportAPI, + } + output, err := client.GetFailingTrustedAdvisorCheckResults() + reflect.DeepEqual(tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } + +} diff --git a/pkg/aws/utils.go b/pkg/aws/utils.go new file mode 100644 index 0000000..59a12b4 --- /dev/null +++ b/pkg/aws/utils.go @@ -0,0 +1,12 @@ +package aws + +// Contains tells whether slice of strings 'ss' contains string 's'. +func Contains(ss []string, s string) bool { + for _, n := range ss { + if s == n { + return true + } + } + return false +} + diff --git a/pkg/aws/utils_test.go b/pkg/aws/utils_test.go new file mode 100644 index 0000000..c7f8c18 --- /dev/null +++ b/pkg/aws/utils_test.go @@ -0,0 +1,40 @@ +package aws + +import ( + "testing" +) + +func TestContains(t *testing.T) { + type args struct { + a []string + x string + } + tests := []struct { + name string + args args + want bool + }{ + { + name: "#1", + args: args{a: []string{"a", "b", "c"}, x: "c"}, + want: true, + }, + { + name: "#2", + args: args{a: []string{"a", "b", "c"}, x: "d"}, + want: false, + }, + { + name: "#3", + args: args{a: []string{}, x: "d"}, + want: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := Contains(tt.args.a, tt.args.x); got != tt.want { + t.Errorf("Contains() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/cloudig/awsconfig.go b/pkg/cloudig/awsconfig.go new file mode 100644 index 0000000..1cb5f9e --- /dev/null +++ b/pkg/cloudig/awsconfig.go @@ -0,0 +1,77 @@ +package cloudig + +import ( + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/configservice" + "github.com/kris-nova/logger" + + awslocal "github.com/Optum/cloudig/pkg/aws" +) + +// ConfigReport is a struct that contains an array of aws config compliance findings +type ConfigReport struct { + Findings []configFinding `json:"findings"` + jsonOutputHelper +} + +type configFinding struct { + AccountID string `json:"accountId"` + RuleName string `json:"ruleName"` + //Description string + Status string `json:"status"` + FlaggedResources map[string][]string `json:"flaggedResources"` + Comments string `json:"comments"` +} + +type configComplianceResult struct { + name string + status string + resultOutput []*configservice.EvaluationResult +} + +// GetReport retrives the aws config compliance report for a given account, +func (report *ConfigReport) GetReport(client awslocal.APIs, comments []Comments) error { + start := time.Now() + finding := configFinding{} + + // Get accountID from session + accountID, err := client.GetAccountID() + if err != nil { + return err + } + logger.Info("working on AWSConfigCompliance report for account: %s", accountID) + finding.AccountID = accountID + + logger.Info("finding failing compliance config rules for account: %s", accountID) + results, err := client.GetNonComplaintConfigRules() + if err != nil { + return err + } + + // Parse results into findings + report.Findings = append(report.Findings, processConfigResults(results, finding, comments)...) + + logger.Success("getting AWSConfigCompliance for account %s took %s", finding.AccountID, time.Since(start)) + return nil +} + +func processConfigResults(results map[string][]*configservice.EvaluationResult, finding configFinding, comments []Comments) []configFinding { + var findings []configFinding + for name, result := range results { + finding.RuleName = name + finding.Status = configservice.ComplianceTypeNonCompliant // keeping this for backword compatibility + finding.Comments = getComments(comments, finding.AccountID, findingTypeAWSConfig, finding.RuleName) + flaggedResources := []string{} + for _, evaluationResult := range result { + if aws.StringValue(evaluationResult.ComplianceType) != configservice.ComplianceTypeCompliant { + flaggedResources = append(flaggedResources, aws.StringValue(evaluationResult.EvaluationResultIdentifier.EvaluationResultQualifier.ResourceId)) + } + } + finding.FlaggedResources = map[string][]string{aws.StringValue(result[0].EvaluationResultIdentifier.EvaluationResultQualifier.ResourceType): flaggedResources} + findings = append(findings, finding) + } + + return findings +} diff --git a/pkg/cloudig/awsconfig_test.go b/pkg/cloudig/awsconfig_test.go new file mode 100644 index 0000000..20f7876 --- /dev/null +++ b/pkg/cloudig/awsconfig_test.go @@ -0,0 +1,270 @@ +package cloudig + +import ( + "errors" + "sort" + "testing" + "time" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/configservice" +) + +func TestAWSConfigGetReport(t *testing.T) { + testCases := []struct { + name string + accountID string + complianceForConfigRules map[string][]*configservice.EvaluationResult + expectedFindings []configFinding + expectedGetAccountIDError error + ComplianceForConfigRulesError error + expectedError error + }{ + { + name: "Return expected report", + accountID: "111111111111", + complianceForConfigRules: map[string][]*configservice.EvaluationResult{ + "ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK": { + { + ComplianceType: aws.String("COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK"), + ResourceId: aws.String("sg-00001"), + ResourceType: aws.String("AWS::EC2::SecurityGroup"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + { + ComplianceType: aws.String("COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK"), + ResourceId: aws.String("sg-00002"), + ResourceType: aws.String("AWS::EC2::SecurityGroup"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + { + ComplianceType: aws.String("NON_COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK"), + ResourceId: aws.String("sg-00003"), + ResourceType: aws.String("AWS::EC2::SecurityGroup"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + }, + "S3_BUCKET_LOGGING_ENABLED": { + { + ComplianceType: aws.String("COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("S3_BUCKET_LOGGING_ENABLED"), + ResourceId: aws.String("222222222222-tfstate-stage"), + ResourceType: aws.String("AWS::S3::Bucket"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + { + ComplianceType: aws.String("NON_COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("S3_BUCKET_LOGGING_ENABLED"), + ResourceId: aws.String("dig-log-bucket-nonprod-222222222222"), + ResourceType: aws.String("AWS::S3::Bucket"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + }, + }, + expectedFindings: []configFinding{ + { + AccountID: "111111111111", + RuleName: "ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK", + Status: "NON_COMPLIANT", + FlaggedResources: map[string][]string{"AWS::EC2::SecurityGroup": {"sg-00003"}}, + Comments: "NEW_FINDING", + }, + { + AccountID: "111111111111", + RuleName: "S3_BUCKET_LOGGING_ENABLED", + Status: "NON_COMPLIANT", + FlaggedResources: map[string][]string{"AWS::S3::Bucket": {"dig-log-bucket-nonprod-222222222222"}}, + Comments: "NEW_FINDING", + }, + }, + expectedGetAccountIDError: nil, + ComplianceForConfigRulesError: nil, + expectedError: nil, + }, + { + name: "Return error when getting AccountID", + accountID: "", + expectedGetAccountIDError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + { + name: "Return error when getting Compliance Details for Config Rules", + accountID: "1234", + ComplianceForConfigRulesError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockAPIs := mocks.NewMockAPIs(mockCtrl) + mockAPIs.EXPECT().GetAccountID().Return(tc.accountID, tc.expectedGetAccountIDError).MaxTimes(1) + mockAPIs.EXPECT().GetNonComplaintConfigRules().Return(tc.complianceForConfigRules, tc.ComplianceForConfigRulesError).MaxTimes(1) + // Use comments file for testing + comments := parseCommentsFile("../../test/data/comments.yaml") + report := ConfigReport{} + err := report.GetReport(mockAPIs, comments) + + sort.SliceStable(tc.expectedFindings, func(i, j int) bool { return tc.expectedFindings[i].RuleName < tc.expectedFindings[j].RuleName }) + sort.SliceStable(report.Findings, func(i, j int) bool { return report.Findings[i].RuleName < report.Findings[j].RuleName }) + assert.Equal(t, tc.expectedFindings, report.Findings) + assert.Equal(t, tc.expectedError, err) + }) + } + +} + +func TestProcessConfigResults(t *testing.T) { + testCases := []struct { + name string + results map[string][]*configservice.EvaluationResult + finding configFinding + expectedOutput []configFinding + }{ + { + name: "Return correct results", + results: map[string][]*configservice.EvaluationResult{ + "ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK": { + { + ComplianceType: aws.String("COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK"), + ResourceId: aws.String("sg-00001"), + ResourceType: aws.String("AWS::EC2::SecurityGroup"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + + { + ComplianceType: aws.String("COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK"), + ResourceId: aws.String("sg-00002"), + ResourceType: aws.String("AWS::EC2::SecurityGroup"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + { + ComplianceType: aws.String("NON_COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK"), + ResourceId: aws.String("sg-00003"), + ResourceType: aws.String("AWS::EC2::SecurityGroup"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + }, + "S3_BUCKET_LOGGING_ENABLED": { + { + ComplianceType: aws.String("COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("S3_BUCKET_LOGGING_ENABLED"), + ResourceId: aws.String("222222222222-tfstate-stage"), + ResourceType: aws.String("AWS::S3::Bucket"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + { + ComplianceType: aws.String("NON_COMPLIANT"), + ConfigRuleInvokedTime: timeHelper(2018, time.December, 21, 8, 38, 52, 0, time.UTC), + EvaluationResultIdentifier: &configservice.EvaluationResultIdentifier{ + EvaluationResultQualifier: &configservice.EvaluationResultQualifier{ + ConfigRuleName: aws.String("S3_BUCKET_LOGGING_ENABLED"), + ResourceId: aws.String("dig-log-bucket-nonprod-222222222222"), + ResourceType: aws.String("AWS::S3::Bucket"), + }, + OrderingTimestamp: timeHelper(2018, time.December, 21, 8, 38, 36, 0, time.UTC), + }, + ResultRecordedTime: timeHelper(2018, time.December, 21, 8, 38, 53, 0, time.UTC), + }, + }, + }, + finding: configFinding{AccountID: "111111111111"}, + expectedOutput: []configFinding{ + { + AccountID: "111111111111", + RuleName: "S3_BUCKET_LOGGING_ENABLED", + Status: "NON_COMPLIANT", + FlaggedResources: map[string][]string{"AWS::S3::Bucket": {"dig-log-bucket-nonprod-222222222222"}}, + Comments: "NEW_FINDING", + }, + { + AccountID: "111111111111", + RuleName: "ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK", + Status: "NON_COMPLIANT", + FlaggedResources: map[string][]string{"AWS::EC2::SecurityGroup": {"sg-00003"}}, + Comments: "NEW_FINDING", + }, + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Use comments file for testing + comments := parseCommentsFile("../../test/data/comments.yaml") + output := processConfigResults(tc.results, tc.finding, comments) + assert.ElementsMatch(t, tc.expectedOutput, output) + }) + } +} + +func timeHelper(year int, month time.Month, day, hour, min, sec, nsec int, loc *time.Location) *time.Time { + t := time.Date(year, month, day, hour, min, sec, nsec, loc) + return &t +} diff --git a/pkg/cloudig/cloudig.go b/pkg/cloudig/cloudig.go new file mode 100644 index 0000000..744dfff --- /dev/null +++ b/pkg/cloudig/cloudig.go @@ -0,0 +1,162 @@ +package cloudig + +import ( + "fmt" + "io/ioutil" + "strings" + "sync" + + "gopkg.in/yaml.v2" + + awslocal "github.com/Optum/cloudig/pkg/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/kris-nova/logger" +) + +// Comments is a Collection of user comments mapped to yaml structure +type Comments struct { + AccountID string `yaml:"accountid"` + TAFindings []map[string]string `yaml:"ta-findings"` + ConfigFindings []map[string]string `yaml:"config-findings"` + InspectorReportFindings []map[string]string `yaml:"inspector-findings"` + HealthReportFindings []map[string]string `yaml:"health-findings"` + ImageScanFindings []map[string]string `yaml:"ecr-findings"` + ReflectIAMFindings []map[string]string `yaml:"reflect-iam-findings"` +} + +const ( + findingTypeTrustedAdvisor string = "ta" + findingTypeAWSConfig string = "config" + findingTypeInspector string = "inspector" + findingTypeAWSHealth string = "health" + findingTypeReflectIAM string = "reflectIAM" + findingTypeECRScan string = "ecrscan" +) + +// Report is an interface that all types of reports will implement +type Report interface { + GetReport(client awslocal.APIs, comments []Comments) error + toJSON(report *Report) string + toTable(tableType string) string +} + +// ProcessReport collects the different reports for each account concurrently +func ProcessReport(sess *session.Session, report Report, outputType string, commentsFile string, roleARNs string) error { + var wg sync.WaitGroup + + // Parse comments file into map and pass to report + comments := parseCommentsFile(commentsFile) + accounts := parseRoleARNs(roleARNs) + logger.Debug("accounts derived from role ARN is: %v", accounts) + parentClient := awslocal.NewClient(sess) + + // Add all go routines to be executed to wait group for effective synchronization + wg.Add(len(accounts)) + es := make([]string, 0) + for i := 0; i < len(accounts); i++ { + go func(i int) { + defer wg.Done() + + // if not the parent account, create a new Client that assumes the role tied to the other account + client := parentClient + if accounts[i] != "parent" { + client = awslocal.NewClientAsAssumeRole(sess, accounts[i]) + } + + err := report.GetReport(client, comments) + if err != nil { + logger.Warning("error getting the report for the account '%s': %v", accounts[i], err) + es = append(es, err.Error()) + } + + }(i) + } + // Wait till all called in go routines are completed successfully + wg.Wait() + + // output only if there is no error on at least one of the account + if len(es) != len(accounts) { + outputReport(report, outputType) + } + + if len(es) != 0 { + return fmt.Errorf(strings.Join(es, "\n")) + } + return nil +} + +// OutputReport outputs a report as JSON, an ASCII table, or a markdown table +func outputReport(reportType Report, outputType string) { + switch outputType { + case tableTypeNormal: + fmt.Println(reportType.toTable(tableTypeNormal)) + case tableTypeMD: + fmt.Println(reportType.toTable(tableTypeMD)) + default: + fmt.Println(reportType.toJSON(&reportType)) + } +} + +// Function that parses comments file into map +func parseCommentsFile(commentsFile string) []Comments { + var comments []Comments + + content, err := ioutil.ReadFile(commentsFile) + if err != nil { + logger.Warning("error reading file %s: %v", commentsFile, err) + } else { + logger.Info("reading comments from file %s", commentsFile) + } + + err = yaml.Unmarshal(content, &comments) + if err != nil { + logger.Warning("unable to parse comments from file %s: %v", commentsFile, err) + } + + return comments +} + +func getComments(comments []Comments, findingAcct string, findingType string, findingName string) string { + for _, ex := range comments { + if ex.AccountID == findingAcct { + switch findingType { + case findingTypeTrustedAdvisor: + return ContainsKey(ex.TAFindings, findingName) + case findingTypeAWSConfig: + return ContainsKey(ex.ConfigFindings, findingName) + case findingTypeInspector: + return ContainsKey(ex.InspectorReportFindings, findingName) + case findingTypeAWSHealth: + return ContainsKey(ex.HealthReportFindings, findingName) + case findingTypeReflectIAM: + return ContainsKey(ex.ReflectIAMFindings, findingName) + case findingTypeECRScan: + var allTag string + tag := strings.Split(findingName, ":") + if len(tag) >= 2 { + allTag = "ALL:" + tag[1] + } + value := ContainsKey(ex.ImageScanFindings, findingName) + if value == "NEW_FINDING" { + return ContainsKey(ex.ImageScanFindings, allTag) + } + return value + default: + return "NEW_FINDING" + } + } + } + return "NEW_FINDING" +} + +// Function that parses string of role ARNs into array +func parseRoleARNs(roleARNs string) []string { + accounts := make([]string, 1) + if roleARNs != "" { + accounts = strings.Split(roleARNs, ",") + } else { + accounts[0] = "parent" + } + + return accounts +} diff --git a/pkg/cloudig/cloudig_test.go b/pkg/cloudig/cloudig_test.go new file mode 100644 index 0000000..e804846 --- /dev/null +++ b/pkg/cloudig/cloudig_test.go @@ -0,0 +1,211 @@ +package cloudig + +import ( + "testing" + + "github.com/go-test/deep" + "github.com/stretchr/testify/assert" +) + +func TestGetComments(t *testing.T) { + comments := []Comments{ + { + AccountID: "TEST_ACCOUNT1", + TAFindings: []map[string]string{{"SECURITY-IAM_Use": "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM"}, {"FAULT_TOLERANCE-Amazon_EBS_Snapshots": "**EXCEPTION:** We do not persist any critical data on EC2 attached EBS. Data present in these disks are ephemeral in nature"}}, + ConfigFindings: []map[string]string{ + {"IAM_POLICY_BLACKLISTED_CHECK": "**EXCEPTION:** Removed the AdminstratorAccess policy since the default AWS_*_Admins uses the policy. Future enhancement would be to create a Custom Rule that no other Role can use the AdmnistratorAccess policy besides the AWS_*_Admins"}, + {"ATTACHED_INTERNET_GATEWAY_CHECK": "**EXCEPTION:** Flags VPCs that have an Internet Gateway attached, Most of our VPC requires IGW enabled in Public subnets as they are web application open to Internet. Better RULE would be to check VPC with all of its SUBNET open to IGW"}, + }, + HealthReportFindings: []map[string]string{{"AWS_RDS_OPERATIONAL_NOTIFICATION": "**EXCEPTION:** Already taken care."}}, + }, + { + AccountID: "TEST_ACCOUNT2", + TAFindings: []map[string]string{ + {"SECURITY-IAM_Use": "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM"}, + {"FAULT_TOLERANCE-Amazon_EBS_Snapshots": "**EXCEPTION:** We do not persist any critical data on EC2 attached EBS. Data present in these disks are ephemeral in nature"}, + }, + ConfigFindings: []map[string]string{{"IAM_POLICY_BLACKLISTED_CHECK": "**EXCEPTION:** Removed the AdminstratorAccess policy since the default AWS_*_Admins uses the policy. Future enhancement would be to create a Custom Rule that no other Role can use the AdmnistratorAccess policy besides the AWS_*_Admins"}, + {"ATTACHED_INTERNET_GATEWAY_CHECK": "**EXCEPTION:** Flags VPCs that have an Internet Gateway attached, Most of our VPC requires IGW enabled in Public subnets as they are web application open to Internet. Better RULE would be to check VPC with all of its SUBNET open to IGW"}, + }, + InspectorReportFindings: []map[string]string{{"CIS_Operating_System_Security_Configuration_Benchmarks-1.0": "**EXCEPTION:** Description here"}}, + ImageScanFindings: []map[string]string{ + {"333333333333.dkr.ecr.us-east-1.amazonaws.com/admin/kube-state-metrics:v1.2.0": "EXCEPTION Patch will applied this weekend"}, + {"ALL:dev": "Still working on it"}, + }, + ReflectIAMFindings: []map[string]string{ + {"arn:aws:iam::111111111111:role/eks-worker-dig-green-dev": "**EXCEPTION:** Ignore AccessDenied error. This role doesn't require s3.amazonaws.com/HeadObject access for its functionality"}, + {"arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass@someuser@company.com": "**EXCEPTION** this role is used by Jenkins and used as a service principal/account"}, + }, + }, + } + + cases := []struct { + findingAccount string + findingType string + findingName string + expectedComments string + }{ + { + findingAccount: "TEST_ACCOUNT1", + findingType: findingTypeTrustedAdvisor, + findingName: "SECURITY-IAM_Use", + expectedComments: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM", + }, + { + findingAccount: "TEST_ACCOUNT1", + findingType: findingTypeAWSConfig, + findingName: "ATTACHED_INTERNET_GATEWAY_CHECK", + expectedComments: "**EXCEPTION:** Flags VPCs that have an Internet Gateway attached, Most of our VPC requires IGW enabled in Public subnets as they are web application open to Internet. Better RULE would be to check VPC with all of its SUBNET open to IGW", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeAWSConfig, + findingName: "IAM_POLICY_BLACKLISTED_CHECK", + expectedComments: "**EXCEPTION:** Removed the AdminstratorAccess policy since the default AWS_*_Admins uses the policy. Future enhancement would be to create a Custom Rule that no other Role can use the AdmnistratorAccess policy besides the AWS_*_Admins", + }, + { + findingAccount: "TEST_ACCOUNT5", + findingType: findingTypeTrustedAdvisor, + findingName: "FAULT_TOLERANCE-Amazon_EBS_Snapshots", + expectedComments: "NEW_FINDING", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeTrustedAdvisor, + findingName: "FAULT_TOLERANCE-S3_SSL", + expectedComments: "NEW_FINDING", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeInspector, + findingName: "CIS_Operating_System_Security_Configuration_Benchmarks-1.0", + expectedComments: "**EXCEPTION:** Description here", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeAWSHealth, + findingName: "AWS_RDS_SECURITY_NOTIFICATION", + expectedComments: "NEW_FINDING", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeReflectIAM, + findingName: "arn:aws:iam::111111111111:role/eks-worker-dig-green-dev", + expectedComments: "**EXCEPTION:** Ignore AccessDenied error. This role doesn't require s3.amazonaws.com/HeadObject access for its functionality", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeECRScan, + findingName: "333333333333.dkr.ecr.us-east-1.amazonaws.com/admin/kube-state-metrics:v1.2.0", + expectedComments: "EXCEPTION Patch will applied this weekend", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeECRScan, + findingName: "333333333333.dkr.ecr.us-east-1.amazonaws.com/admin/sample:dev", + expectedComments: "Still working on it", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeECRScan, + findingName: "333333333333.dkr.ecr.us-east-1.amazonaws.com/admin/sample:prod", + expectedComments: "NEW_FINDING", + }, + { + findingAccount: "TEST_ACCOUNT2", + findingType: findingTypeReflectIAM, + findingName: "arn:aws:iam::111111111111:role/do-it-all-role", + expectedComments: "NEW_FINDING", + }, + } + + for _, c := range cases { + actualComments := getComments(comments, c.findingAccount, c.findingType, c.findingName) + if diff := deep.Equal(c.expectedComments, actualComments); diff != nil { + t.Fatalf("Expected comments are not correct, the difference is %s", diff) + } + } + +} + +func TestParseRoleARNs(t *testing.T) { + testCases := []struct { + name string + roleARNs string + expectedOutput []string + }{ + { + name: "emptyStringPassed#1", + roleARNs: "", + expectedOutput: []string{"parent"}, + }, + { + name: "roleARNsPassed#2", + roleARNs: "arn:aws:iam::123456:role/cloudig,arn:aws:iam::78910:role/cloudig", + expectedOutput: []string{"arn:aws:iam::123456:role/cloudig", "arn:aws:iam::78910:role/cloudig"}, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + output := parseRoleARNs(tc.roleARNs) + assert.Equal(t, tc.expectedOutput, output) + }) + } +} + +func TestParseCommentsFile(t *testing.T) { + testCases := []struct { + name string + file string + expectedOutput []Comments + }{ + { + name: "returnExpectedCommentsArray#1", + file: "../../test/data/comments.yaml", + expectedOutput: []Comments{ + { + AccountID: "111111111111", + TAFindings: []map[string]string{{"SECURITY-IAM_Use": "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM"}}, + ConfigFindings: []map[string]string{{"IAM_POLICY_BLACKLISTED_CHECK": "**EXCEPTION:** Removed the AdminstratorAccess policy since the default AWS_*_Admins uses the policy. Future enhancement would be to create a Custom Rule that no other Role can use the AdmnistratorAccess policy besides the AWS_*_Admins"}}, + InspectorReportFindings: []map[string]string{{"CIS_Operating_System_Security_Configuration_Benchmarks-1.0": "**EXCEPTION:** Description here"}}, + HealthReportFindings: []map[string]string{{"AWS_RDS_SECURITY_NOTIFICATION": "**EXCEPTION:** Description here"}}, + ReflectIAMFindings: []map[string]string{{"arn:aws:iam::111111111111:role/eks-worker-dig-green-dev": "**EXCEPTION:** Ignore AccessDenied error. This role doesn't require s3.amazonaws.com/HeadObject access for its functionality"}}, + }, + { + AccountID: "222222222222", + TAFindings: []map[string]string{ + {"SECURITY-IAM_Use": "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM"}, + {"FAULT_TOLERANCE-Amazon_EBS_Snapshots": "**EXCEPTION:** We do not persist any critical data on EC2 attached EBS. Data present in these disks are ephemeral in nature"}, + }, + ConfigFindings: []map[string]string{ + {"ATTACHED_INTERNET_GATEWAY_CHECK": "**EXCEPTION:** Flags VPCs that have an Internet Gateway attached, Most of our VPC requires IGW enabled in Public subnets as they are web application open to Internet. Better RULE would be to check VPC with all of its SUBNET open to IGW"}, + {"IAM_POLICY_BLACKLISTED_CHECK": "**EXCEPTION:** Removed the AdminstratorAccess policy since the default AWS_*_Admins uses the policy. Future enhancement would be to create a Custom Rule that no other Role can use the AdmnistratorAccess policy besides the AWS_*_Admins"}, + }, + }, + { + AccountID: "012345678910", + ImageScanFindings: []map[string]string{ + {"012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server:prod-canary": "EXCEPTION Patch will applied this weekend"}, + {"ALL:v1.2.0": "EXCEPTION Patch is coming tomorrow"}, + }, + }, + }, + }, + { + name: "returnEmptyCommentsArrayWhenCommentsFileCan'tBeParsed#2", + file: "../../test/data/inspector_report_test.html", + expectedOutput: []Comments(nil), + }, + { + name: "returnEmptyCommentsArrayWhenCommentsFileDoesn'tExist#3", + file: "", + expectedOutput: []Comments(nil), + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + output := parseCommentsFile(tc.file) + assert.Equal(t, tc.expectedOutput, output) + }) + } +} diff --git a/pkg/cloudig/ecrscan.go b/pkg/cloudig/ecrscan.go new file mode 100644 index 0000000..cc8642d --- /dev/null +++ b/pkg/cloudig/ecrscan.go @@ -0,0 +1,103 @@ +package cloudig + +import ( + "time" + + awslocal "github.com/Optum/cloudig/pkg/aws" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ecr" + "github.com/kris-nova/logger" +) + +// ImageScanReports struct specify the format of scan reports +type ImageScanReports struct { + Findings []ImageScanFindings `json:"findings"` + Flags ImageScanReportFlags `json:"-"` // hide in json output + jsonOutputHelper +} + +// ImageScanReportFlags struct specify the format of passed in flags +type ImageScanReportFlags struct { + Tag string `json:"tag,omitempty"` + Region string `json:"region"` +} + +// ImageScanFindings struct specify the scan finding reports format +type ImageScanFindings struct { + AccountID string `json:"accountId"` + ImageDigest string `json:"imageDigest"` + ImageTag string `json:"imageTag"` + RepositoryName string `json:"repositoryName"` + ImageFindingsCount map[string]int64 `json:"imageFindingsCount"` + Comments string `json:"comments"` + Region string `json:"region"` +} + +// GetReport of the vulnerability count of the images of the builds +func (report *ImageScanReports) GetReport(client awslocal.APIs, comments []Comments) error { + start := time.Now() + + // Get accountID from roleARN + accountID, err := client.GetAccountID() + if err != nil { + return err + } + logger.Info("working on ECR Scan report for account: %s", accountID) + + // Get all images with a given tag + if report.Flags.Tag != "" { + logger.Info("finding all ECR images with tag: %s for account: %s in region: %s", report.Flags.Tag, accountID, report.Flags.Region) + } else { + logger.Info("finding all tagged ECR images for account: %s in region: %s", accountID, report.Flags.Region) + } + images, err := client.GetECRImagesWithTag(report.Flags.Tag) + if err != nil { + return err + } + + // Create findings + for repo, imageList := range images { + // If a tag was specified there should only be one image returned per repo + if report.Flags.Tag != "" && len(imageList) == 1 { + imageURI := repo + ":" + report.Flags.Tag + scanReport := ImageScanFindings{ + AccountID: accountID, + ImageDigest: aws.StringValue(imageList[0].ImageDigest), + ImageTag: report.Flags.Tag, + RepositoryName: aws.StringValue(imageList[0].RepositoryName), + ImageFindingsCount: convertScanFindings(imageList[0]), + Comments: getComments(comments, accountID, findingTypeECRScan, imageURI), + Region: report.Flags.Region, + } + report.Findings = append(report.Findings, scanReport) + } else { + // Create finding for each tag + for _, image := range imageList { + for _, tag := range aws.StringValueSlice(image.ImageTags) { + imageURI := repo + ":" + tag + scanReport := ImageScanFindings{ + AccountID: accountID, + ImageDigest: aws.StringValue(image.ImageDigest), + ImageTag: tag, + RepositoryName: aws.StringValue(image.RepositoryName), + ImageFindingsCount: convertScanFindings(image), + Comments: getComments(comments, accountID, findingTypeECRScan, imageURI), + Region: report.Flags.Region, + } + report.Findings = append(report.Findings, scanReport) + } + } + } + } + + logger.Success("getting ECR Scan Results for account %s took %s", accountID, time.Since(start)) + return nil +} + +func convertScanFindings(image *ecr.ImageDetail) map[string]int64 { + if image != nil && image.ImageScanStatus != nil && aws.StringValue(image.ImageScanStatus.Status) == "COMPLETE" { + return aws.Int64ValueMap(image.ImageScanFindingsSummary.FindingSeverityCounts) + } + return nil +} diff --git a/pkg/cloudig/ecrscan_test.go b/pkg/cloudig/ecrscan_test.go new file mode 100644 index 0000000..fc98397 --- /dev/null +++ b/pkg/cloudig/ecrscan_test.go @@ -0,0 +1,169 @@ +package cloudig + +import ( + "errors" + "testing" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ecr" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" +) + +func TestImageScanReports_GetReport(t *testing.T) { + testCases := []struct { + name string + accountID string + tag string + region string + getECRImagesWithTagResponse map[string][]*ecr.ImageDetail + expectedFindings []ImageScanFindings + getAccountIDError error + getECRImagesWithTagResponseError error + expectedError error + }{ + { + name: "Get basic ECR scan report containing all tagged images", + accountID: "012345678910", + region: "us-east-1", + getECRImagesWithTagResponse: map[string][]*ecr.ImageDetail{ + "012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server": { + { + ImageTags: aws.StringSlice([]string{"prod-canary", "test"}), + ImageDigest: aws.String("sha256:e0fa362f30aa43f11d1d5e1822ef3117e03782cdd921aaab73267e1219a4fde2"), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + ImageScanStatus: &ecr.ImageScanStatus{ + Status: aws.String("COMPLETE"), + }, + ImageScanFindingsSummary: &ecr.ImageScanFindingsSummary{ + FindingSeverityCounts: map[string]*int64{ + "HIGH": aws.Int64(2), + "MEDIUM": aws.Int64(8), + }, + }, + }, + }, + "012345678910.dkr.ecr.us-east-1.amazonaws.com/app/hello-world": { + { + ImageTags: aws.StringSlice([]string{"test"}), + ImageDigest: aws.String("sha256:4e3bc79a145b6bb5756f8f52f60853e842a1681ace8b5115a715c892f4957ea9"), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/hello-world"), + ImageScanStatus: &ecr.ImageScanStatus{ + Status: aws.String("FAILED"), + }, + }, + }, + }, + expectedFindings: []ImageScanFindings{ + { + AccountID: "012345678910", + ImageDigest: "sha256:e0fa362f30aa43f11d1d5e1822ef3117e03782cdd921aaab73267e1219a4fde2", + ImageTag: "prod-canary", + RepositoryName: "app/web-server", + ImageFindingsCount: map[string]int64{ + "HIGH": 2, + "MEDIUM": 8, + }, + Comments: "EXCEPTION Patch will applied this weekend", + Region: "us-east-1", + }, + { + AccountID: "012345678910", + ImageDigest: "sha256:e0fa362f30aa43f11d1d5e1822ef3117e03782cdd921aaab73267e1219a4fde2", + ImageTag: "test", + RepositoryName: "app/web-server", + ImageFindingsCount: map[string]int64{ + "HIGH": 2, + "MEDIUM": 8, + }, + Comments: "NEW_FINDING", + Region: "us-east-1", + }, + { + AccountID: "012345678910", + ImageDigest: "sha256:4e3bc79a145b6bb5756f8f52f60853e842a1681ace8b5115a715c892f4957ea9", + ImageTag: "test", + RepositoryName: "app/hello-world", + Comments: "NEW_FINDING", + Region: "us-east-1", + }, + }, + }, + { + name: "Get ECR scan report containing all images having the tag 'test'", + accountID: "012345678910", + region: "us-east-1", + tag: "test", + getECRImagesWithTagResponse: map[string][]*ecr.ImageDetail{ + "012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server": { + { + ImageTags: aws.StringSlice([]string{"prod-canary", "test"}), + ImageDigest: aws.String("sha256:e0fa362f30aa43f11d1d5e1822ef3117e03782cdd921aaab73267e1219a4fde2"), + RegistryId: aws.String("012345678910"), + RepositoryName: aws.String("app/web-server"), + ImageScanStatus: &ecr.ImageScanStatus{ + Status: aws.String("COMPLETE"), + }, + ImageScanFindingsSummary: &ecr.ImageScanFindingsSummary{ + FindingSeverityCounts: map[string]*int64{ + "HIGH": aws.Int64(2), + "MEDIUM": aws.Int64(8), + }, + }, + }, + }, + }, + expectedFindings: []ImageScanFindings{ + { + AccountID: "012345678910", + ImageDigest: "sha256:e0fa362f30aa43f11d1d5e1822ef3117e03782cdd921aaab73267e1219a4fde2", + ImageTag: "test", + RepositoryName: "app/web-server", + ImageFindingsCount: map[string]int64{ + "HIGH": 2, + "MEDIUM": 8, + }, + Comments: "NEW_FINDING", + Region: "us-east-1", + }, + }, + }, + { + name: "Return error while retrieving the AccountID", + getAccountIDError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + { + name: "Return error while retrieving tagged image information", + accountID: "012345678910", + getECRImagesWithTagResponseError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockAPIs := mocks.NewMockAPIs(mockCtrl) + mockAPIs.EXPECT().GetAccountID().Return(tc.accountID, tc.getAccountIDError).MaxTimes(1) + mockAPIs.EXPECT().GetECRImagesWithTag(tc.tag).Return(tc.getECRImagesWithTagResponse, tc.getECRImagesWithTagResponseError).MaxTimes(1) + // Use comments file for testing + comments := parseCommentsFile("../../test/data/comments.yaml") + + report := &ImageScanReports{ + Flags: ImageScanReportFlags{ + Tag: tc.tag, + Region: tc.region, + }, + } + err := report.GetReport(mockAPIs, comments) + + assert.ElementsMatch(t, tc.expectedFindings, report.Findings) + assert.Equal(t, tc.expectedError, err) + }) + } +} diff --git a/pkg/cloudig/health.go b/pkg/cloudig/health.go new file mode 100644 index 0000000..7a57ad2 --- /dev/null +++ b/pkg/cloudig/health.go @@ -0,0 +1,245 @@ +package cloudig + +import ( + "errors" + "strconv" + "strings" + "time" + + "gopkg.in/neurosnap/sentences.v1/english" + + awslocal "github.com/Optum/cloudig/pkg/aws" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/health" + "github.com/kris-nova/logger" +) + +// HealthReport is a struct that contains an array of healthReport +type HealthReport struct { + Findings []healthReportFinding `json:"findings"` + Flags healthReportFlags `json:"-"` // hide in json output + jsonOutputHelper +} + +type healthReportFlags struct { + Details bool + PastDays string +} + +type healthReportFinding struct { + AccountID string `json:"accountId"` + Arn string `json:"arn"` + AffectedEntities []string `json:"affectedEntities"` + Comments string `json:"comments"` + EventTypeCode string `json:"eventTypeCode"` + LastUpdatedTime string `json:"lastUpdatedTime"` + Region string `json:"region"` + StatusCode string `json:"statusCode"` + EventDescription string `json:"eventDescription"` +} + +// GetReport builds the Inspector report for a given assessment run +func (report *HealthReport) GetReport(client awslocal.APIs, comments []Comments) error { + start := time.Now() + + // Get accountID from roleARN + accountID, err := client.GetAccountID() + if err != nil { + return err + } + logger.Info("working on AWS HealthReport for account: %s", accountID) + + logger.Info("finding all health events for account: %s", accountID) + // get basic event info, and create arn array to then query specifically for detailed output + arnArr, err := createArnArray(client, report.Flags) + if err != nil { + return err + } + // get all wanted available information from the Health Event(corresponding details and affected entities) + eventDetails, err := getAllEventDetails(client, arnArr, 10) + if err != nil { + return err + } + + logger.Info("finding affected entities for health events in account: %s", accountID) + // a map is needed here to synchronize with eventdetails + affectedEntities, err := getAllAffectedEntities(client, arnArr, 10) + if err != nil { + return err + } + + if len(eventDetails.FailedSet) > 0 { + return errors.New("One of the provided arns failed to provide details") + } + // parse to the format that wil be outputted + for _, details := range eventDetails.SuccessfulSet { + eventDes, err := scrubEventDescription(*details.EventDescription.LatestDescription, report.Flags.Details) + if err != nil { + return err + } + finding := healthReportFinding{ + AccountID: accountID, + AffectedEntities: affectedEntities[*details.Event.Arn], + Arn: *details.Event.Arn, + Comments: getComments(comments, accountID, findingTypeAWSHealth, *details.Event.EventTypeCode), + EventTypeCode: scrubEventTypeCode(*details.Event.EventTypeCode), + LastUpdatedTime: (*details.Event.LastUpdatedTime).String(), + Region: *details.Event.Region, + StatusCode: *details.Event.StatusCode, + EventDescription: eventDes, + } + report.Findings = append(report.Findings, finding) + } + + logger.Success("getting AWS HealthReport for account %s took %s", accountID, time.Since(start)) + return nil +} + +func createArnArray(client awslocal.APIs, flags healthReportFlags) ([]*string, error) { + eventsArray := make([]*health.Event, 0) + // Process flags into the event filter as desired + if flags.PastDays == "" { + // create unused value to mark all events + flags.PastDays = "0" + } + pastDays, err := strconv.Atoi(flags.PastDays) + if err != nil { + return nil, err + } + // No scenario someone would look in the future, but someone might confuse positive and negative here + if pastDays < 0 { + pastDays *= -1 + } + + eventFilter := &health.EventFilter{ + EventTypeCategories: []*string{aws.String("accountNotification")}, + EventStatusCodes: []*string{aws.String("open"), aws.String("upcoming")}, + LastUpdatedTimes: []*health.DateTimeRange{ + { + From: func() *time.Time { + if pastDays != 0 { + return aws.Time(time.Now().AddDate(0, 0, -pastDays)) + } + return nil + }(), + }, + }, + } + + var nextToken *string + for { + events, err := client.GetHealthEvents(eventFilter, nextToken) + if err != nil { + return nil, err + } + for _, event := range events.Events { + eventsArray = append(eventsArray, event) + } + if events.NextToken == nil { + break + } + nextToken = events.NextToken + } + + arnArr := make([]*string, len(eventsArray)) + for i, event := range eventsArray { + arnArr[i] = event.Arn + } + + return arnArr, nil +} + +func getAllEventDetails(client awslocal.APIs, arnArr []*string, maxCallSize int) (*health.DescribeEventDetailsOutput, error) { + eventDetailsSuccessArray := make([]*health.EventDetails, 0) + eventDetailsErrorItemArray := make([]*health.EventDetailsErrorItem, 0) + for i := 0; i < len(arnArr); i += maxCallSize { + eventDetails, err := client.GetHealthEventDetails(arnArr[i:min(len(arnArr), i+maxCallSize)]) + if err != nil { + return nil, err + } + for _, eventD := range eventDetails.SuccessfulSet { + eventDetailsSuccessArray = append(eventDetailsSuccessArray, eventD) + } + for _, eventD := range eventDetails.FailedSet { + eventDetailsErrorItemArray = append(eventDetailsErrorItemArray, eventD) + } + } + + // combine array of arrays of event details to one array + eventDetails := health.DescribeEventDetailsOutput{ + SuccessfulSet: eventDetailsSuccessArray, + FailedSet: eventDetailsErrorItemArray, + } + return &eventDetails, nil +} + +func getAllAffectedEntities(client awslocal.APIs, arnArr []*string, maxCallSize int) (map[string][]string, error) { + eventArnToEntityValueMap := make(map[string][]string) + // we may only call GetHealthAffectedEntities, and its underlying health method, DescribeAffectedEntities->EntityFilter, with an array of + // a 10 strings, thus have to have the cap, the for loop, and have pagination option for the many possible entites returned for each call + for i := 0; i < len(arnArr); i += maxCallSize { + var nextToken *string + for { + affectedEntitiesOutput, err := client.GetHealthAffectedEntities(arnArr[i:min(len(arnArr), i+maxCallSize)], nextToken) + if err != nil { + return nil, err + } + for _, entity := range affectedEntitiesOutput.Entities { + eventArnToEntityValueMap[*entity.EventArn] = append(eventArnToEntityValueMap[*entity.EventArn], *entity.EntityValue) + } + if affectedEntitiesOutput.NextToken == nil { + break + } + nextToken = affectedEntitiesOutput.NextToken + } + } + return eventArnToEntityValueMap, nil +} + +func scrubEventTypeCode(name string) string { + // Remove AWS_ as it is redundant, remove underscores, and capitalize normally + parts := strings.Split(name, "_") + if parts[0] == "AWS" { + parts = parts[1:] + } + for i, part := range parts { + parts[i] = strings.Title(strings.ToLower(part)) + } + return strings.Join(parts, " ") +} + +func scrubEventDescription(eventDesc string, details bool) (string, error) { + // parse the string as the event description is printed as a raw string, + // not rendered + replacer := strings.NewReplacer( + "\u003e", "", + "\u0085", "", + "\u2028", "", + "\u2029", "", + "\"", "'", + "\r\n*", "", + "\r\n\r\n", " ", + "\r\n", " ", + "\r", "", + "\n", "", + "\v", "", + "\f", "", + ) + + proccessedDesc := replacer.Replace(eventDesc) + if details { + return proccessedDesc, nil + } + + tokenizer, err := english.NewSentenceTokenizer(nil) + if err != nil { + return "", err + } + + sentences := tokenizer.Tokenize(proccessedDesc) + str := "" + for i := 0; i < min(3, len(sentences)); i++ { + str += sentences[i].Text + } + return str, nil +} diff --git a/pkg/cloudig/health_test.go b/pkg/cloudig/health_test.go new file mode 100644 index 0000000..5c9c793 --- /dev/null +++ b/pkg/cloudig/health_test.go @@ -0,0 +1,413 @@ +package cloudig + +import ( + "errors" + "testing" + "time" + + "github.com/aws/aws-sdk-go/aws" + + "github.com/Optum/cloudig/pkg/mocks" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/service/health" +) + +func TestGetHealthReport(t *testing.T) { + testCases := []struct { + name string + eventInput []*string + eventFilter *health.EventFilter + eventAPIResponses []*health.DescribeEventsOutput + detailInput [][]*string + detailAPIResponses []*health.DescribeEventDetailsOutput + entityInputArn [][]*string + entityInputToken []*string + entityAPIResponses []*health.DescribeAffectedEntitiesOutput + expectedOutput []healthReportFinding + expectedError error + }{ + { + name: "Basic Get Report Run", + eventInput: []*string{nil}, + eventFilter: &health.EventFilter{ + EventTypeCategories: []*string{aws.String("accountNotification")}, + EventStatusCodes: []*string{aws.String("open"), aws.String("upcoming")}, + LastUpdatedTimes: []*health.DateTimeRange{ + {}, + }, + }, + eventAPIResponses: []*health.DescribeEventsOutput{ + { + Events: []*health.Event{ + { + Arn: aws.String("arn1"), + }, + }, + NextToken: nil, + }, + }, + detailInput: [][]*string{ + {aws.String("arn1")}, + }, + detailAPIResponses: []*health.DescribeEventDetailsOutput{ + { + SuccessfulSet: []*health.EventDetails{ + { + Event: &health.Event{ + Arn: aws.String("arn1"), + Region: aws.String("region"), + EventTypeCode: aws.String("EVENT_CODE"), + LastUpdatedTime: &time.Time{}, + StatusCode: aws.String("status"), + }, + EventDescription: &health.EventDescription{ + LatestDescription: aws.String("description"), + }, + }, + }, + }, + }, + entityInputArn: [][]*string{ + {aws.String("arn1")}, + }, + entityInputToken: []*string{nil, aws.String("a token")}, + entityAPIResponses: []*health.DescribeAffectedEntitiesOutput{ + { + Entities: []*health.AffectedEntity{ + { + EntityValue: aws.String("entity value1"), + EventArn: aws.String("arn1"), + }, + }, + NextToken: nil, + }, + }, + expectedError: nil, + expectedOutput: []healthReportFinding{ + { + AccountID: "account", + AffectedEntities: []string{"entity value1"}, + Arn: "arn1", + Comments: "NEW_FINDING", + EventTypeCode: "Event Code", + LastUpdatedTime: "0001-01-01 00:00:00 +0000 UTC", + Region: "region", + StatusCode: "status", + EventDescription: "description", + }, + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + // loop through checks and simulate calling method and returning corresponding responses + mockAPIs := mocks.NewMockAPIs(mockCtrl) + mockAPIs.EXPECT().GetAccountID().Return("account", nil).MaxTimes(1) + for i := 0; i < len(tc.eventInput); i++ { + mockAPIs.EXPECT().GetHealthEvents(tc.eventFilter, tc.eventInput[i]).Return(tc.eventAPIResponses[i], tc.expectedError).MaxTimes(len(tc.eventInput)) + mockAPIs.EXPECT().GetHealthEventDetails(tc.detailInput[i]).Return(tc.detailAPIResponses[i], tc.expectedError).MaxTimes(len(tc.detailInput)) + mockAPIs.EXPECT().GetHealthAffectedEntities(tc.entityInputArn[i], tc.entityInputToken[i]).Return(tc.entityAPIResponses[i], tc.expectedError).MaxTimes(len(tc.entityInputToken)) + } + + comments := parseCommentsFile("../../test/data/comments.yaml") + report := &HealthReport{ + Flags: healthReportFlags{ + Details: false, + PastDays: "", + }, + } + err := report.GetReport(mockAPIs, comments) + + assert.Equal(t, tc.expectedOutput, report.Findings) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestCreateArnArray(t *testing.T) { + testCases := []struct { + name string + input []*string + eventFilter *health.EventFilter + apiResponses []*health.DescribeEventsOutput + expectedOutput []*string + expectedError error + }{ + { + name: "Return Events with a next token one time", + input: []*string{nil, aws.String("a token")}, + eventFilter: &health.EventFilter{ + EventTypeCategories: []*string{aws.String("accountNotification")}, + EventStatusCodes: []*string{aws.String("open"), aws.String("upcoming")}, + LastUpdatedTimes: []*health.DateTimeRange{ + {}, + }, + }, + apiResponses: []*health.DescribeEventsOutput{ + { + Events: []*health.Event{ + { + Arn: aws.String("arn1"), + }, + }, + NextToken: aws.String("a token"), + }, + { + Events: []*health.Event{ + { + Arn: aws.String("arn2"), + }, + }, + NextToken: nil, + }, + }, + expectedOutput: []*string{aws.String("arn1"), aws.String("arn2")}, + expectedError: nil, + }, + { + name: "Return error", + input: []*string{nil}, + eventFilter: &health.EventFilter{ + EventTypeCategories: []*string{aws.String("accountNotification")}, + EventStatusCodes: []*string{aws.String("open"), aws.String("upcoming")}, + LastUpdatedTimes: []*health.DateTimeRange{ + {}, + }, + }, + apiResponses: []*health.DescribeEventsOutput{ + nil, + }, + expectedOutput: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + // loop through checks and simulate calling method and returning corresponding responses + mockAPIs := mocks.NewMockAPIs(mockCtrl) + for i := 0; i < len(tc.input); i++ { + mockAPIs.EXPECT().GetHealthEvents(tc.eventFilter, tc.input[i]).Return(tc.apiResponses[i], tc.expectedError).MaxTimes(len(tc.input)) + } + + output, err := createArnArray(mockAPIs, healthReportFlags{}) + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestGetAllEventDetails(t *testing.T) { + testCases := []struct { + name string + input [][]*string + apiResponses []*health.DescribeEventDetailsOutput + expectedOutput *health.DescribeEventDetailsOutput + expectedError error + }{ + { + name: "Return Events Details with only successful sets", + input: [][]*string{ + {aws.String("arn1")}, + {aws.String("arn2")}, + }, + apiResponses: []*health.DescribeEventDetailsOutput{ + { + SuccessfulSet: []*health.EventDetails{ + { + Event: &health.Event{ + Arn: aws.String("arn1"), + }, + }, + }, + }, + { + SuccessfulSet: []*health.EventDetails{ + { + Event: &health.Event{ + Arn: aws.String("arn2"), + }, + }, + }, + }, + }, + expectedOutput: &health.DescribeEventDetailsOutput{ + SuccessfulSet: []*health.EventDetails{ + { + Event: &health.Event{ + Arn: aws.String("arn1"), + }, + }, + { + Event: &health.Event{ + Arn: aws.String("arn2"), + }, + }, + }, + FailedSet: []*health.EventDetailsErrorItem{}, + }, + expectedError: nil, + }, + { + name: "Return Events Details with a failed set", + input: [][]*string{ + {aws.String("arn1")}, + {aws.String("arn2")}, + }, + apiResponses: []*health.DescribeEventDetailsOutput{ + { + FailedSet: []*health.EventDetailsErrorItem{ + { + EventArn: aws.String("arn1"), + }, + }, + }, + { + FailedSet: []*health.EventDetailsErrorItem{ + { + EventArn: aws.String("arn2"), + }, + }, + }, + }, + expectedOutput: &health.DescribeEventDetailsOutput{ + SuccessfulSet: []*health.EventDetails{}, + FailedSet: []*health.EventDetailsErrorItem{ + { + EventArn: aws.String("arn1"), + }, + { + EventArn: aws.String("arn2"), + }, + }, + }, + expectedError: nil, + }, + { + name: "Return error", + input: [][]*string{ + {aws.String("arn1")}, + }, + apiResponses: []*health.DescribeEventDetailsOutput{ + nil, + }, + expectedOutput: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + // loop through checks and simulate calling method and returning corresponding responses + mockAPIs := mocks.NewMockAPIs(mockCtrl) + for i := 0; i < len(tc.input); i++ { + mockAPIs.EXPECT().GetHealthEventDetails(tc.input[i]).Return(tc.apiResponses[i], tc.expectedError).MaxTimes(len(tc.input)) + } + + output, err := getAllEventDetails(mockAPIs, []*string{aws.String("arn1"), aws.String("arn2")}, 1) + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestGetAllAffectedEntities(t *testing.T) { + testCases := []struct { + name string + inputArn [][]*string + inputToken []*string + apiResponses []*health.DescribeAffectedEntitiesOutput + expectedOutput map[string][]string + expectedError error + }{ + { + name: "Return Affected entities", + inputArn: [][]*string{ + {aws.String("arn1"), aws.String("arn2")}, + {aws.String("arn1"), aws.String("arn2")}, + }, + inputToken: []*string{nil, aws.String("a token")}, + apiResponses: []*health.DescribeAffectedEntitiesOutput{ + { + Entities: []*health.AffectedEntity{ + { + EntityValue: aws.String("entity value1"), + EventArn: aws.String("arn1"), + }, + }, + NextToken: aws.String("a token"), + }, + { + Entities: []*health.AffectedEntity{ + { + EntityValue: aws.String("entity value2"), + EventArn: aws.String("arn2"), + }, + }, + NextToken: nil, + }, + }, + expectedOutput: map[string][]string{ + "arn1": {"entity value1"}, + "arn2": {"entity value2"}, + }, + expectedError: nil, + }, + { + name: "Return error", + inputArn: [][]*string{ + {aws.String("arn1"), aws.String("arn2")}, + }, + inputToken: []*string{nil}, + apiResponses: []*health.DescribeAffectedEntitiesOutput{ + nil, + }, + expectedOutput: nil, + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + // loop through checks and simulate calling method and returning corresponding responses + mockAPIs := mocks.NewMockAPIs(mockCtrl) + for i := 0; i < len(tc.inputToken); i++ { + mockAPIs.EXPECT().GetHealthAffectedEntities(tc.inputArn[i], tc.inputToken[i]).Return(tc.apiResponses[i], tc.expectedError).MaxTimes(len(tc.inputToken)) + } + + output, err := getAllAffectedEntities(mockAPIs, []*string{aws.String("arn1"), aws.String("arn2")}, 2) + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestScrubEventTypeCode(t *testing.T) { + output := scrubEventTypeCode("AWS_STRING_ONE_TWO_THREE") + assert.Equal(t, "String One Two Three", output) + output = scrubEventTypeCode("STRING_ONE_TWO_THREE") + assert.Equal(t, "String One Two Three", output) +} + +func TestScrubEventDescription(t *testing.T) { + output, _ := scrubEventDescription("One.\n\r Two.\n Three.\r Four.", true) + assert.Equal(t, "One. Two. Three. Four.", output) + output, _ = scrubEventDescription("One.\n\r Two.\n Three.\r Four.", false) + assert.Equal(t, "One. Two. Three.", output) +} diff --git a/pkg/cloudig/inspector.go b/pkg/cloudig/inspector.go new file mode 100644 index 0000000..ef09954 --- /dev/null +++ b/pkg/cloudig/inspector.go @@ -0,0 +1,297 @@ +package cloudig + +import ( + "io" + "net/http" + "os" + "strings" + "time" + + "github.com/PuerkitoBio/goquery" + "github.com/kris-nova/logger" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ec2" + + awslocal "github.com/Optum/cloudig/pkg/aws" +) + +// InspectorReports is a struct that contains an array of inspectorReport +type InspectorReports struct { + Reports []inspectorReport `json:"reports"` + Helper reportDownloader `json:"-"` + jsonOutputHelper +} + +type inspectorReport struct { + AccountID string `json:"accountId"` + TemplateName string `json:"templateName"` + Findings []inspectorReportFinding `json:"findings"` + AMI map[string]int `json:"amis"` +} + +type inspectorReportFinding struct { + RulePackageName string `json:"rulePackage"` + High string `json:"high"` + Medium string `json:"medium"` + Low string `json:"low"` + Informational string `json:"informational"` + Comments string `json:"comments"` +} + +// InspectorHelper is a struct that implements the reportDownloader interface inorder to fake downloading a report for testing scenarios +type InspectorHelper struct{} + +type reportDownloader interface { + downloadReport(reportURL string, report inspectorReport) (string, error) +} + +// GetReport builds the Inspector report for a given assessment run +func (reports *InspectorReports) GetReport(client awslocal.APIs, comments []Comments) error { + start := time.Now() + report := inspectorReport{} + + // Get accountID from session + accountID, err := client.GetAccountID() + if err != nil { + return err + } + logger.Info("working on Inspector report for account: %s", accountID) + report.AccountID = accountID + + logger.Info("finding most recent assessment run for template(s) in account: %s", accountID) + // Get most recent Assessment Run ARNs for each template + assessmentRunInfo, err := client.GetMostRecentAssessmentRunInfo() + if err != nil { + return err + } + + // Generate report from ARN and download file + for _, run := range assessmentRunInfo { + report.TemplateName = run["templateName"] + reportURL, err := client.GenerateReport(run["arn"], "HTML", "FULL") + if err != nil { + return err + } + logger.Info("generating a report for %s in account: %s", run["templateName"], accountID) + + reportFile, err := reports.Helper.downloadReport(reportURL, report) + if err != nil { + return err + } + + logger.Info("parsing report for findings in account: %s", accountID) + // Parse report page HTML and build table of findings + reportFindings, err := getReportFindings(reportFile, comments, report) + if err != nil { + return err + } + report.Findings = reportFindings + + logger.Info("finding AMI properties associated with the scan in account: %s", accountID) + + // Get list of AMIS that have a given list of tags and their age in days + amiAgeMap, err := getAssessmentRunAgentAMIAndAge(client, run["targetArn"]) + if err != nil { + return err + } + report.AMI = amiAgeMap + + // Add to final report + reports.Reports = append(reports.Reports, report) + + } + + logger.Success("getting Inspector Report for account %s took %s", report.AccountID, time.Since(start)) + return nil +} + +func getReportFindings(reportFile string, comments []Comments, report inspectorReport) ([]inspectorReportFinding, error) { + var reportFindings []inspectorReportFinding + // Parse report page HTML, build list of findings, then delete report + table, err := parseReportTable(reportFile) + if err != nil { + return nil, err + } + + err = deleteFile(reportFile) + if err != nil { + return nil, err + } + + for _, row := range table { + inspectorReportFinding := inspectorReportFinding{} + for index, col := range row { + switch index { + case 0: + inspectorReportFinding.RulePackageName = col + case 1: + inspectorReportFinding.High = col + case 2: + inspectorReportFinding.Medium = col + case 3: + inspectorReportFinding.Low = col + case 4: + inspectorReportFinding.Informational = col + default: + logger.Warning("error parsing finding table from the report") + } + } + + reportFindings = append(reportFindings, inspectorReportFinding) + } + + // Get comments for findings + for i, finding := range reportFindings { + // Format rule package name into comment format + // ex. CIS Operating System Security Configuration 1.0 => CIS_Operating_System_Security_Configuration-1.0 + commentFinding := strings.Replace(finding.RulePackageName, " ", "_", -1) + reportFindings[i].Comments = "" + if !isZeroFindings(finding) { + reportFindings[i].Comments = getComments(comments, report.AccountID, findingTypeInspector, commentFinding) + } + } + + return reportFindings, nil +} + +func isZeroFindings(finding inspectorReportFinding) bool { + if finding.High == "0" && finding.Medium == "0" && finding.Low == "0" && finding.Informational == "0" { + return true + } + return false +} + +// Parse report, build table, and delete report +func parseReportTable(filepath string) ([][]string, error) { + file, err := os.Open(filepath) + if err != nil { + return nil, err + } + defer file.Close() + + doc, err := goquery.NewDocumentFromReader(file) + if err != nil { + return nil, err + } + + var table [][]string + doc.Find("tbody").Each(func(index int, tablehtml *goquery.Selection) { + // Only parse second table + if index == 1 { + tablehtml.Find("tr").Each(func(indextr int, rowhtml *goquery.Selection) { + // Don't parse header row + var row []string + if indextr > 0 { + rowhtml.Find("td").Each(func(indextd int, tablecell *goquery.Selection) { + row = append(row, strings.TrimSpace(tablecell.Text())) + }) + table = append(table, row) + } + }) + } + }) + + return table, nil +} + +func getAgeInDays(creationDate string) int { + today := time.Now() + date, _ := time.Parse(time.RFC3339, creationDate) + timeInDays := int(today.Sub(date).Hours()) / 24 + + return timeInDays +} + +// Get unique list of Image Ids for agents associated with an assessment target +func getAssessmentRunAgentAMIAndAge(client awslocal.APIs, targetArn string) (map[string]int, error) { + tags, err := client.GetResourceGroupTags(targetArn) + if err != nil { + return nil, err + } + + instancesList, err := client.GetInstancesMatchingAnyTags(tags) + if err != nil { + return nil, err + } + + amiList := unique(getAmiList(instancesList)) + + // Get age of AMIs in days + imageInformation, err := client.GetImageInformation(amiList) + if err != nil { + return nil, err + } + amiAgeMap := getAmiAgeMap(imageInformation) + + return amiAgeMap, nil +} + +func getAmiList(instancesList *ec2.DescribeInstancesOutput) []string { + var amiList []string + + for _, res := range instancesList.Reservations { + for _, inst := range res.Instances { + amiList = append(amiList, aws.StringValue(inst.ImageId)) + } + } + return amiList +} + +func getAmiAgeMap(imageInformation *ec2.DescribeImagesOutput) map[string]int { + amiAgeMap := make(map[string]int) + for _, image := range imageInformation.Images { + amiAgeMap[aws.StringValue(image.Name)] = getAgeInDays(aws.StringValue(image.CreationDate)) + } + return amiAgeMap +} + +func unique(amiList []string) []string { + keys := make(map[string]bool) + list := []string{} + for _, entry := range amiList { + if _, value := keys[entry]; !value { + keys[entry] = true + list = append(list, entry) + } + } + return list +} + +func downloadFile(filepath string, url string) error { + // Get the data + resp, err := http.Get(url) + if err != nil { + return err + } + defer resp.Body.Close() + + // Create the file + out, err := os.Create(filepath) + if err != nil { + return err + } + defer out.Close() + + // Write the body to file + _, err = io.Copy(out, resp.Body) + return err +} + +func (helper *InspectorHelper) downloadReport(reportURL string, report inspectorReport) (string, error) { + reportFile := "/tmp/inspector_report_" + report.AccountID + ".html" + // Download report to tmp folder + err := downloadFile(reportFile, reportURL) + if err != nil { + return "", err + } + return reportFile, nil +} + +func deleteFile(filePath string) error { + err := os.Remove(filePath) + if err != nil { + return err + } + return nil +} diff --git a/pkg/cloudig/inspector_test.go b/pkg/cloudig/inspector_test.go new file mode 100644 index 0000000..97476ea --- /dev/null +++ b/pkg/cloudig/inspector_test.go @@ -0,0 +1,640 @@ +package cloudig + +import ( + "errors" + "io/ioutil" + "log" + "os" + "reflect" + "testing" + "time" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/ec2" + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" +) + +// fakeInspectorHelper is used to fake downloading a report in TestInspectorGetReport +type fakeInspectorHelper struct{} + +func (fakeHelper *fakeInspectorHelper) downloadReport(reportURL string, report inspectorReport) (string, error) { + // Create copy of test inspector report for testing so original isn't deleted + reportFile := "/tmp/inspector_report_" + report.AccountID + ".html" + err := copy("../../test/data/inspector_report_test.html", reportFile) + if err != nil { + log.Fatalf("Error copying file: %s\n", err) + } + return reportFile, nil +} + +func TestInspectorGetReport(t *testing.T) { + testCases := []struct { + name string + accountID string + assessmentRunInfo []map[string]string + resourceGroupTags map[string]string + instancesList *ec2.DescribeInstancesOutput + imageInformation *ec2.DescribeImagesOutput + expectedReports []inspectorReport + expectedGetAccountIDError error + expectedGetMostRecentAssessmentRunInfoError error + expectedGenerateReportError error + expectedGetInstancesMatchingAnyTagsError error + expectedGetResourceGroupTagsError error + expectedGetImageInformationError error + expectedError error + }{ + { + name: "Return expected report", + accountID: "111111111111", + assessmentRunInfo: []map[string]string{ + { + "templateName": "test-once-dev", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW/template/0-qLRbgV2x/run/0-gKfIrDIK", + }, + { + "templateName": "k8s_weekly_scan", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF/template/0-eLtPoQf3/run/0-8Wf02Drc", + }, + }, + resourceGroupTags: map[string]string{ + "dig-owned": "True", + "aws_inspector": "true", + "terraform": "True", + }, + instancesList: &ec2.DescribeInstancesOutput{ + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("ami-123"), + }, + { + ImageId: aws.String("ami-777"), + }, + }, + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("ami-777"), + }, + }, + }, + }, + }, + imageInformation: &ec2.DescribeImagesOutput{ + Images: []*ec2.Image{ + { + Name: aws.String("TEST_AMI"), + ImageId: aws.String("ami-123"), + CreationDate: aws.String("2019-11-03T05:57:38.000Z"), + }, + { + Name: aws.String("TEST_AMI_2"), + ImageId: aws.String("ami-777"), + CreationDate: aws.String("2019-12-08T05:57:38.000Z"), + }, + }, + }, + expectedReports: []inspectorReport{ + { + AccountID: "111111111111", + TemplateName: "test-once-dev", + Findings: []inspectorReportFinding{ + { + RulePackageName: "CIS Operating System Security Configuration Benchmarks-1.0", + High: "2581", + Medium: "0", + Low: "0", + Informational: "232", + Comments: "**EXCEPTION:** Description here", + }, + { + RulePackageName: "Common Vulnerabilities and Exposures-1.1", + High: "29", + Medium: "46", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Runtime Behavior Analysis-1.0", + High: "0", + Medium: "0", + Low: "23", + Informational: "44", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Security Best Practices-1.0", + High: "0", + Medium: "0", + Low: "0", + Informational: "0", + Comments: "", + }, + }, + AMI: map[string]int{ + "TEST_AMI": getAgeInDays("2019-11-03T05:57:38.000Z"), + "TEST_AMI_2": getAgeInDays("2019-12-08T05:57:38.000Z"), + }, + }, + { + AccountID: "111111111111", + TemplateName: "k8s_weekly_scan", + Findings: []inspectorReportFinding{ + { + RulePackageName: "CIS Operating System Security Configuration Benchmarks-1.0", + High: "2581", + Medium: "0", + Low: "0", + Informational: "232", + Comments: "**EXCEPTION:** Description here", + }, + { + RulePackageName: "Common Vulnerabilities and Exposures-1.1", + High: "29", + Medium: "46", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Runtime Behavior Analysis-1.0", + High: "0", + Medium: "0", + Low: "23", + Informational: "44", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Security Best Practices-1.0", + High: "0", + Medium: "0", + Low: "0", + Informational: "0", + Comments: "", + }, + }, + AMI: map[string]int{ + "TEST_AMI": getAgeInDays("2019-11-03T05:57:38.000Z"), + "TEST_AMI_2": getAgeInDays("2019-12-08T05:57:38.000Z"), + }, + }, + }, + expectedError: nil, + }, + { + + name: "Return error when getting AccountID", + accountID: "", + instancesList: &ec2.DescribeInstancesOutput{}, + imageInformation: &ec2.DescribeImagesOutput{}, + expectedGetAccountIDError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + { + name: "Return error when getting most recent Assement Run ARN", + accountID: "111111111111", + assessmentRunInfo: []map[string]string{ + { + "templateName": "test-once-dev", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW/template/0-qLRbgV2x/run/0-gKfIrDIK", + }, + { + "templateName": "k8s_weekly_scan", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF/template/0-eLtPoQf3/run/0-8Wf02Drc", + }, + }, + instancesList: &ec2.DescribeInstancesOutput{}, + imageInformation: &ec2.DescribeImagesOutput{}, + expectedGetMostRecentAssessmentRunInfoError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + { + name: "Return error when generating report", + accountID: "111111111111", + assessmentRunInfo: []map[string]string{ + { + "templateName": "test-once-dev", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW/template/0-qLRbgV2x/run/0-gKfIrDIK", + }, + { + "templateName": "k8s_weekly_scan", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF/template/0-eLtPoQf3/run/0-8Wf02Drc", + }, + }, + instancesList: &ec2.DescribeInstancesOutput{}, + imageInformation: &ec2.DescribeImagesOutput{}, + expectedGenerateReportError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + { + name: "Return error when getting list of AMIs and their ages", + accountID: "111111111111", + assessmentRunInfo: []map[string]string{ + { + "templateName": "test-once-dev", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-4S2UxUbW/template/0-qLRbgV2x/run/0-gKfIrDIK", + }, + { + "templateName": "k8s_weekly_scan", + "targetArn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF", + "arn": "arn:aws:inspector:us-east-1:111111111111:target/0-E70Tx7xF/template/0-eLtPoQf3/run/0-8Wf02Drc", + }, + }, + instancesList: &ec2.DescribeInstancesOutput{}, + imageInformation: &ec2.DescribeImagesOutput{}, + expectedGetInstancesMatchingAnyTagsError: errors.New("Some API error"), + expectedGetImageInformationError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockAPIs := mocks.NewMockAPIs(mockCtrl) + mockAPIs.EXPECT().GetAccountID().Return(tc.accountID, tc.expectedGetAccountIDError).MaxTimes(1) + mockAPIs.EXPECT().GetMostRecentAssessmentRunInfo().Return(tc.assessmentRunInfo, tc.expectedGetMostRecentAssessmentRunInfoError).MaxTimes(1) + // We don't care about the reportURL returned by GenerateReport since we are using a local test report for getting findings + for _, run := range tc.assessmentRunInfo { + mockAPIs.EXPECT().GenerateReport(run["arn"], "HTML", "FULL").Return("", tc.expectedGenerateReportError).MaxTimes(len(tc.assessmentRunInfo)) + mockAPIs.EXPECT().GetResourceGroupTags(run["targetArn"]).Return(tc.resourceGroupTags, tc.expectedGetResourceGroupTagsError).MaxTimes(len(tc.assessmentRunInfo)) + mockAPIs.EXPECT().GetInstancesMatchingAnyTags(tc.resourceGroupTags).Return(tc.instancesList, tc.expectedGetInstancesMatchingAnyTagsError).MaxTimes(len(tc.assessmentRunInfo)) + mockAPIs.EXPECT().GetImageInformation(unique(getAmiList(tc.instancesList))).Return(tc.imageInformation, tc.expectedGetImageInformationError).MaxTimes(len(tc.assessmentRunInfo)) + } + reports := &InspectorReports{Helper: &fakeInspectorHelper{}} + + // Use fakeInspectorReport's downloadReport method + comments := parseCommentsFile("../../test/data/comments.yaml") + + err := reports.GetReport(mockAPIs, comments) + assert.Equal(t, tc.expectedReports, reports.Reports) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestGetAssessmentRunAgentAMIAndAge(t *testing.T) { + testCases := []struct { + name string + resourceGroupTags map[string]string + instancesList *ec2.DescribeInstancesOutput + imageInformation *ec2.DescribeImagesOutput + expectedGetResourceGroupTagsError error + expectedGetInstancesMatchingAnyTagsError error + expectedGetImageInformationError error + expectedOutput map[string]int + expectedError error + }{ + { + name: "Return correct map of AMIs and ages", + resourceGroupTags: map[string]string{ + "dig-owned": "True", + "aws_inspector": "true", + "terraform": "True", + }, + instancesList: &ec2.DescribeInstancesOutput{ + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("ami-123"), + }, + { + ImageId: aws.String("ami-777"), + }, + }, + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("ami-777"), + }, + }, + }, + }, + }, + imageInformation: &ec2.DescribeImagesOutput{ + Images: []*ec2.Image{ + { + Name: aws.String("TEST_AMI"), + ImageId: aws.String("ami-123"), + CreationDate: aws.String("2019-11-03T05:57:38.000Z"), + }, + { + Name: aws.String("TEST_AMI_2"), + ImageId: aws.String("ami-777"), + CreationDate: aws.String("2019-12-08T05:57:38.000Z"), + }, + }, + }, + expectedOutput: map[string]int{ + "TEST_AMI": getAgeInDays("2019-11-03T05:57:38.000Z"), + "TEST_AMI_2": getAgeInDays("2019-12-08T05:57:38.000Z"), + }, + expectedError: nil, + }, + { + name: "Return error when calling GetResourceGroupTags", + instancesList: &ec2.DescribeInstancesOutput{}, + imageInformation: &ec2.DescribeImagesOutput{}, + expectedGetResourceGroupTagsError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + { + name: "Return error when calling GetInstancesByTags", + resourceGroupTags: map[string]string{ + "dig-owned": "True", + "aws_inspector": "true", + "terraform": "True", + }, + instancesList: &ec2.DescribeInstancesOutput{}, + imageInformation: &ec2.DescribeImagesOutput{}, + expectedGetInstancesMatchingAnyTagsError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + { + name: "Return error when calling GetImageInformation", + resourceGroupTags: map[string]string{ + "dig-owned": "True", + "aws_inspector": "true", + "terraform": "True", + }, + instancesList: &ec2.DescribeInstancesOutput{ + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("ami-123"), + }, + { + ImageId: aws.String("ami-777"), + }, + }, + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("ami-777"), + }, + }, + }, + }, + }, + imageInformation: &ec2.DescribeImagesOutput{}, + expectedGetImageInformationError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockAPIs := mocks.NewMockAPIs(mockCtrl) + mockAPIs.EXPECT().GetResourceGroupTags(gomock.Any()).Return(tc.resourceGroupTags, tc.expectedGetResourceGroupTagsError).MaxTimes(1) + mockAPIs.EXPECT().GetInstancesMatchingAnyTags(tc.resourceGroupTags).Return(tc.instancesList, tc.expectedGetInstancesMatchingAnyTagsError).MaxTimes(1) + mockAPIs.EXPECT().GetImageInformation(unique(getAmiList(tc.instancesList))).Return(tc.imageInformation, tc.expectedGetImageInformationError).MaxTimes(1) + + // We don't care about what is passed in for the targetArn for this test. We are testing what is returned + output, err := getAssessmentRunAgentAMIAndAge(mockAPIs, "") + assert.Equal(t, tc.expectedOutput, output) + assert.Equal(t, tc.expectedError, err) + }) + } + +} + +// TestDownloadFile needs internet access +func TestDownloadFile(t *testing.T) { + url := "https://golangcode.com/images/avatar.jpg" + path := "./avatar.jpg" + + err := downloadFile(path, url) + if err != nil { + t.Fatalf("Expected err to be nil but it was: %s", err) + } + + err = deleteFile(path) + if err != nil { + t.Fatalf("Expected err to be nil but it was: %s", err) + } +} + +func TestGetReportFindings(t *testing.T) { + expectedFindings := []inspectorReportFinding{ + { + RulePackageName: "CIS Operating System Security Configuration Benchmarks-1.0", + High: "2581", + Medium: "0", + Low: "0", + Informational: "232", + Comments: "**EXCEPTION:** Description here", + }, + { + RulePackageName: "Common Vulnerabilities and Exposures-1.1", + High: "29", + Medium: "46", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Runtime Behavior Analysis-1.0", + High: "0", + Medium: "0", + Low: "23", + Informational: "44", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Security Best Practices-1.0", + High: "0", + Medium: "0", + Low: "0", + Informational: "0", + Comments: "", + }, + } + + // Create copy of test inspector report for testing so original isn't deleted + fileName := "test.html" + err := copy("../../test/data/inspector_report_test.html", fileName) + if err != nil { + log.Fatalf("Error copying file: %s\n", err) + } + + comments := parseCommentsFile("../../test/data/comments.yaml") + report := inspectorReport{AccountID: "111111111111"} + + findings, err := getReportFindings(fileName, comments, report) + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(expectedFindings, findings) { + t.Fatalf("Expected %s, got %s", expectedFindings, findings) + } +} + +func TestGetAgeInDays(t *testing.T) { + expectedResult := 7 + // Get date that is 7 days ago from today + today := time.Now() + weekAgo := today.AddDate(0, 0, -7).Format(time.RFC3339) + + // Convert to string for function + actualResult := getAgeInDays(weekAgo) + + if actualResult != expectedResult { + t.Fatalf("Expected %d days, got %d days", expectedResult, actualResult) + } +} + +func TestDeleteFile(t *testing.T) { + // Create file, delete it, then check if it was deleted / still exists + filePath := "./dummy.txt" + _, err := os.Create(filePath) + if err != nil { + t.Fatalf("Expected err to be nil but it was: %s", err) + } + + err = deleteFile(filePath) + if err != nil { + t.Fatalf("Expected err to be nil but it was: %s", err) + } + + _, err = os.Stat(filePath) + if !os.IsNotExist(err) { + t.Fatalf("Expected err to be nil but it was: %s", err) + } +} + +func TestParseReportTable(t *testing.T) { + expectedResult := [][]string{ + {"CIS Operating System Security Configuration Benchmarks-1.0", "2581", "0", "0", "232"}, + {"Common Vulnerabilities and Exposures-1.1", "29", "46", "0", "0"}, + {"Runtime Behavior Analysis-1.0", "0", "0", "23", "44"}, + {"Security Best Practices-1.0", "0", "0", "0", "0"}, + } + + result, err := parseReportTable("../../test/data/inspector_report_test.html") + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(expectedResult, result) { + t.Fatalf("Expected %s, got %s", expectedResult, result) + } +} + +func TestGetAmiAgeMap(t *testing.T) { + // Pass portion of describe images API response for test + instancesList := &ec2.DescribeImagesOutput{ + Images: []*ec2.Image{ + { + CreationDate: aws.String("2019-07-07T05:58:28.000Z"), + Description: aws.String("AMI with metrics provider, ssm, ossec, awslogs, code deploy & inspector"), + ImageId: aws.String("ami-01afe9fb62487c917"), + ImageLocation: aws.String("111111111111/encrypted-amzn2-ami-k8s-2.0-ssm-ossec-awslogs-inspector-2019-07-07"), + ImageType: aws.String("machine"), + Name: aws.String("encrypted-amzn2-ami-k8s-2.0-ssm-ossec-awslogs-inspector-2019-07-07"), + }, + { + CreationDate: aws.String("2019-07-07T05:38:28.000Z"), + Description: aws.String("AMI for egress proxy with squid proxy, metrics provider, ssm, ossec, awslogs, code deploy & inspector"), + Hypervisor: aws.String("xen"), + ImageId: aws.String("ami-0d69650d24f16e93a"), + ImageLocation: aws.String("111111111111/encrypted-amzn2-ami-hvm-2.0-squid-ssm-ossec-awslogs-inspector-2019-07-07"), + ImageType: aws.String("machine"), + Name: aws.String("encrypted-amzn2-ami-hvm-2.0-squid-ssm-ossec-awslogs-inspector-2019-07-07"), + }, + }, + } + + expectedResult := map[string]int{ + "encrypted-amzn2-ami-k8s-2.0-ssm-ossec-awslogs-inspector-2019-07-07": getAgeInDays("2019-07-07T05:58:28.000Z"), + "encrypted-amzn2-ami-hvm-2.0-squid-ssm-ossec-awslogs-inspector-2019-07-07": getAgeInDays("2019-07-07T05:38:28.000Z"), + } + + result := getAmiAgeMap(instancesList) + + if !reflect.DeepEqual(result, expectedResult) { + t.Fatalf("Expected %v, got %v", expectedResult, result) + } + +} + +func TestGetAmiList(t *testing.T) { + // Pass portion of list instances API response for test + instancesList := &ec2.DescribeInstancesOutput{ + Reservations: []*ec2.Reservation{ + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("ami-1234"), + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-05c3b42e310f42c23"), + }, + { + Instances: []*ec2.Instance{ + { + ImageId: aws.String("ami-4444"), + }, + { + ImageId: aws.String("ami-555"), + }, + }, + OwnerId: aws.String("111111111111"), + RequesterId: aws.String("940372691376"), + ReservationId: aws.String("r-0d2fb4dab0c28956a"), + }, + }, + } + + expectedResult := []string{"ami-1234", "ami-4444", "ami-555"} + result := getAmiList(instancesList) + + if !reflect.DeepEqual(result, expectedResult) { + t.Fatalf("Expected %s, got %s", expectedResult, result) + } + +} + +func TestUnique(t *testing.T) { + testList := []string{"a", "a", "b", "c", "c"} + expectedResult := []string{"a", "b", "c"} + + result := unique(testList) + + if !reflect.DeepEqual(result, expectedResult) { + t.Fatalf("Expected %s, got %s", expectedResult, result) + } +} + +func copy(src, dst string) error { + data, err := ioutil.ReadFile(src) + if err != nil { + return err + } + + err = ioutil.WriteFile(dst, data, 0644) + if err != nil { + return err + } + return nil +} diff --git a/pkg/cloudig/output.go b/pkg/cloudig/output.go new file mode 100644 index 0000000..77efb7e --- /dev/null +++ b/pkg/cloudig/output.go @@ -0,0 +1,183 @@ +package cloudig + +import ( + "encoding/json" + "fmt" + "strconv" + "strings" + "time" + + "github.com/kris-nova/logger" + "github.com/olekukonko/tablewriter" +) + +const ( + tableTypeNormal string = "table" + tableTypeMD string = "mdtable" +) + +type jsonOutputHelper struct { + ReportTime string `json:"reportTime"` +} + +func (helper *jsonOutputHelper) toJSON(report *Report) string { + helper.ReportTime = getCurrentTimestamp() + content, err := json.MarshalIndent(report, "", " ") + + if err != nil { + logger.Critical("unable to marshal the output into JSON: %v", err) + } + return string(content) +} + +func (report *TrustedAdvisorReport) toTable(tableType string) string { + report.ReportTime = getCurrentTimestamp() + table, tableString := getTableWriterWithHeaders(tableType, []string{"Account ID", "Name", "Flagged Resources", "Comments"}) + // build table rows + for _, finding := range report.Findings { + nameCol := finding.Category + "\n" + finding.Name + flaggedResourcesCol := "Flagged Count: " + strconv.Itoa(len(finding.FlaggedResources)) + "\n" + strings.Join(finding.FlaggedResources, "\n") + table.Append([]string{finding.AccountID, nameCol, flaggedResourcesCol, finding.Comments}) + } + + logger.Always("report Time: %s", report.ReportTime) + table.Render() + + return tableString.String() +} + +func (report *ConfigReport) toTable(tableType string) string { + report.ReportTime = getCurrentTimestamp() + + table, tableString := getTableWriterWithHeaders(tableType, []string{"Account ID", "Name", "Flagged Resources", "Comments"}) + // build table rows + for _, finding := range report.Findings { + var flaggedResourcesCol string + for resourceType, flaggedResources := range finding.FlaggedResources { + flaggedResourcesCol = "Resource Type: " + resourceType + "\n" + strings.Join(flaggedResources, "\n") + } + table.Append([]string{finding.AccountID, finding.RuleName, flaggedResourcesCol, finding.Comments}) + } + + logger.Always("report Time: %s", report.ReportTime) + table.Render() + + return tableString.String() +} + +func (reports *InspectorReports) toTable(tableType string) string { + reports.ReportTime = getCurrentTimestamp() + findingsTable, findingsTableString := getTableWriterWithHeaders(tableType, []string{"Account ID", "Template Name", "Rule Packages", "High", "Medium", "Low", "Informational", "Comments"}) + + amiTable, amiTableString := getTableWriterWithHeaders(tableType, []string{"Account ID", "AMI", "Age"}) + amiTable.SetAutoMergeCells(true) + + // build tables + for _, report := range reports.Reports { + for _, finding := range report.Findings { + findingsTable.Append([]string{report.AccountID, report.TemplateName, finding.RulePackageName, finding.High, finding.Medium, finding.Low, finding.Informational, finding.Comments}) + } + } + + for _, report := range reports.Reports { + for ami, age := range report.AMI { + amiTable.Append([]string{report.AccountID, ami, strconv.Itoa(age) + " days"}) + } + } + + logger.Always("report Time: %s", reports.ReportTime) + findingsTable.Render() + amiTable.Render() + + return findingsTableString.String() + amiTableString.String() +} + +func (report *HealthReport) toTable(tableType string) string { + report.ReportTime = getCurrentTimestamp() + + table, tableString := getTableWriterWithHeaders(tableType, []string{"Account ID", "Event Type Code", "Region", "Status Code", "Event Description", "Affected Resources", "Comments"}) + // build table rows + for _, finding := range report.Findings { + table.Append([]string{finding.AccountID, finding.EventTypeCode, finding.Region, finding.StatusCode, finding.EventDescription, strings.Join(finding.AffectedEntities, ", "), finding.Comments}) + } + + logger.Always("report Time: %s", report.ReportTime) + table.Render() + + return tableString.String() +} + +func (report *ImageScanReports) toTable(tableType string) string { + report.ReportTime = getCurrentTimestamp() + + table, tableString := getTableWriterWithHeaders(tableType, []string{"Account ID", "Region", "Repository Name", "Tag", "Vulnerabilities(count)", "Comments"}) + table.SetHeaderAlignment(tablewriter.ALIGN_LEFT) + table.SetAlignment(tablewriter.ALIGN_LEFT) + // build table rows + previousAccountID := "" + previousRepo := "" + previousRegion := "" + for _, finding := range report.Findings { + var severityCount string + for severity, count := range finding.ImageFindingsCount { + severityCount = severityCount + fmt.Sprintf("%-15v %d\n", severity+":", count) + } + severityCount = strings.Trim(severityCount, "\n") + if previousAccountID != finding.AccountID && previousRepo != finding.RepositoryName && previousRegion != finding.Region { + table.Append([]string{finding.AccountID, finding.Region, finding.RepositoryName, finding.ImageTag, severityCount, finding.Comments}) + } else if previousAccountID == finding.AccountID && previousRegion != finding.Region && previousRepo != finding.RepositoryName { + table.Append([]string{"", finding.Region, finding.RepositoryName, finding.ImageTag, severityCount, finding.Comments}) + } else if previousAccountID == finding.AccountID && previousRegion == finding.Region && previousRepo != finding.RepositoryName { + table.Append([]string{"", "", finding.RepositoryName, finding.ImageTag, severityCount, finding.Comments}) + } else { + table.Append([]string{"", "", "", finding.ImageTag, severityCount, finding.Comments}) + } + previousAccountID = finding.AccountID + previousRepo = finding.RepositoryName + previousRegion = finding.Region + } + + logger.Always("report Time: %s", report.ReportTime) + table.Render() + + return tableString.String() +} + +func (report *ReflectReport) toTable(tableType string) string { + report.ReportTime = getCurrentTimestamp() + + table, tableString := getTableWriterWithHeaders(tableType, []string{"Account ID", "IAM Identity", "Access Details", "Actual Permissions", "Comments"}) + // build table rows + for _, finding := range report.Findings { + details := make([]string, 0) + for _, ad := range finding.AccessDetails { + details = append(details, ad.Event+":"+strconv.Itoa(ad.Count)) + } + accDetCol := strings.Join(details, "\n") + perSetCol := strings.Join(finding.PermissionSet, "\n") + table.Append([]string{finding.AccountID, finding.Identity, accDetCol, perSetCol, finding.Comments}) + } + + logger.Always("report Time: %s", report.ReportTime) + table.Render() + + return tableString.String() +} + +func getCurrentTimestamp() string { + return time.Now().Format(time.RFC822) +} + +func getTableWriterWithHeaders(tableType string, headers []string) (*tablewriter.Table, *strings.Builder) { + tableString := &strings.Builder{} + table := tablewriter.NewWriter(tableString) + table.SetHeader(headers) + if tableType == tableTypeNormal { + table.SetRowLine(true) + table.SetRowSeparator("-") + } else if tableType == tableTypeMD { + table.SetBorders(tablewriter.Border{Left: true, Top: false, Right: true, Bottom: false}) + table.SetCenterSeparator("|") + } + return table, tableString +} diff --git a/pkg/cloudig/output_test.go b/pkg/cloudig/output_test.go new file mode 100644 index 0000000..a037185 --- /dev/null +++ b/pkg/cloudig/output_test.go @@ -0,0 +1,733 @@ +package cloudig + +import ( + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/support" + "github.com/stretchr/testify/assert" +) + +func TestTrustedAdvisorTableOutput(t *testing.T) { + testCases := []struct { + name string + report *TrustedAdvisorReport + tableType string + expectedOutput string + }{ + { + name: "returnPopulatedTable#1", + report: &TrustedAdvisorReport{ + Findings: []trustedAdvisorFinding{ + { + AccountID: "111111111111", + Category: "COST_OPTIMIZING", + Name: "Low Utilization Amazon EC2 Instances", + Description: `Checks the Amazon Elastic Compute Cloud (Amazon EC2) instances that were running at any time during the last 14 days and alerts you if the daily CPU utilization was 10% or less and network I/O was 5 MB or less on 4 or more days. Running instances generate hourly usage charges. Although some scenarios can result in low utilization by design, you can often lower your costs by managing the number and size of your instances.`, + Status: "warning", + ResourcesSummary: support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(10), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(12), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []string{"i-0123456789abcdefg", "i-abcdefg0123456789"}, + Comments: "NEW_FINDING", + }, { + AccountID: "111111111111", + Category: "SECURITY", + Name: "IAM Use", + Description: "Checks for your use of AWS Identity and Access Management (IAM). You can use IAM to create users, groups, and roles in AWS, and you can use permissions to control access to AWS resources.", + Status: "warning", + ResourcesSummary: support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(1), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(1), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []string{"NA"}, + Comments: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM", + }, + }, + }, + tableType: tableTypeNormal, + expectedOutput: `+--------------+--------------------------------+---------------------+--------------------------------+ +| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | ++--------------+--------------------------------+---------------------+--------------------------------+ +| 111111111111 | COST_OPTIMIZING Low | Flagged Count: 2 | NEW_FINDING | +| | Utilization Amazon EC2 | i-0123456789abcdefg | | +| | Instances | i-abcdefg0123456789 | | ++--------------+--------------------------------+---------------------+--------------------------------+ +| 111111111111 | SECURITY | Flagged Count: 1 | **EXCEPTION:** We use | +| | IAM Use | NA | Federation and IAM roles to | +| | | | manage resources in AWS . No | +| | | | users/groups created in IAM | ++--------------+--------------------------------+---------------------+--------------------------------+ +`, + }, + { + name: "returnEmptyTable#2", + report: &TrustedAdvisorReport{}, + tableType: tableTypeNormal, + expectedOutput: `+------------+------+-------------------+----------+ +| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | ++------------+------+-------------------+----------+ +`, + }, + { + name: "returnPopulatedMDTable#3", + report: &TrustedAdvisorReport{ + Findings: []trustedAdvisorFinding{ + { + AccountID: "111111111111", + Category: "COST_OPTIMIZING", + Name: "Low Utilization Amazon EC2 Instances", + Description: `Checks the Amazon Elastic Compute Cloud (Amazon EC2) instances that were running at any time during the last 14 days and alerts you if the daily CPU utilization was 10% or less and network I/O was 5 MB or less on 4 or more days. Running instances generate hourly usage charges. Although some scenarios can result in low utilization by design, you can often lower your costs by managing the number and size of your instances.`, + Status: "warning", + ResourcesSummary: support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(10), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(12), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []string{"i-0123456789abcdefg", "i-abcdefg0123456789"}, + Comments: "NEW_FINDING", + }, { + AccountID: "111111111111", + Category: "SECURITY", + Name: "IAM Use", + Description: "Checks for your use of AWS Identity and Access Management (IAM). You can use IAM to create users, groups, and roles in AWS, and you can use permissions to control access to AWS resources.", + Status: "warning", + ResourcesSummary: support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(1), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(1), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []string{"NA"}, + Comments: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM", + }, + }, + }, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | +|--------------|--------------------------------|---------------------|--------------------------------| +| 111111111111 | COST_OPTIMIZING Low | Flagged Count: 2 | NEW_FINDING | +| | Utilization Amazon EC2 | i-0123456789abcdefg | | +| | Instances | i-abcdefg0123456789 | | +| 111111111111 | SECURITY | Flagged Count: 1 | **EXCEPTION:** We use | +| | IAM Use | NA | Federation and IAM roles to | +| | | | manage resources in AWS . No | +| | | | users/groups created in IAM | +`, + }, + { + name: "returnEmptyMDTable#4", + report: &TrustedAdvisorReport{}, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | +|------------|------|-------------------|----------| +`, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + output := tc.report.toTable(tc.tableType) + assert.Equal(t, tc.expectedOutput, output) + }) + } +} + +func TestAWSConfigTableOutput(t *testing.T) { + testCases := []struct { + name string + report *ConfigReport + tableType string + expectedOutput string + }{ + { + name: "returnPopulatedTable#1", + report: &ConfigReport{ + Findings: []configFinding{ + { + AccountID: "111111111111", + RuleName: "ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK", + Status: "NON_COMPLIANT", + FlaggedResources: map[string][]string{"AWS::EC2::SecurityGroup": {"sg-00003"}}, + Comments: "NEW_FINDING", + }, + { + AccountID: "111111111111", + RuleName: "S3_BUCKET_LOGGING_ENABLED", + Status: "NON_COMPLIANT", + FlaggedResources: map[string][]string{"AWS::S3::Bucket": {"dig-log-bucket-nonprod-222222222222"}}, + Comments: "NEW_FINDING", + }, + }, + }, + tableType: tableTypeNormal, + expectedOutput: `+--------------+---------------------------------------------+-------------------------------------+-------------+ +| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | ++--------------+---------------------------------------------+-------------------------------------+-------------+ +| 111111111111 | ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK | Resource Type: | NEW_FINDING | +| | | AWS::EC2::SecurityGroup | | +| | | sg-00003 | | ++--------------+---------------------------------------------+-------------------------------------+-------------+ +| 111111111111 | S3_BUCKET_LOGGING_ENABLED | Resource Type: AWS::S3::Bucket | NEW_FINDING | +| | | dig-log-bucket-nonprod-222222222222 | | ++--------------+---------------------------------------------+-------------------------------------+-------------+ +`, + }, + { + name: "returnEmptyRable#2", + report: &ConfigReport{}, + tableType: tableTypeNormal, + expectedOutput: `+------------+------+-------------------+----------+ +| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | ++------------+------+-------------------+----------+ +`, + }, + { + name: "returnPopulatedMDTable#3", + report: &ConfigReport{ + Findings: []configFinding{ + { + AccountID: "111111111111", + RuleName: "ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK", + Status: "NON_COMPLIANT", + FlaggedResources: map[string][]string{"AWS::EC2::SecurityGroup": {"sg-00003"}}, + Comments: "NEW_FINDING", + }, + { + AccountID: "111111111111", + RuleName: "S3_BUCKET_LOGGING_ENABLED", + Status: "NON_COMPLIANT", + FlaggedResources: map[string][]string{"AWS::S3::Bucket": {"dig-log-bucket-nonprod-222222222222"}}, + Comments: "NEW_FINDING", + }, + }, + }, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | +|--------------|---------------------------------------------|-------------------------------------|-------------| +| 111111111111 | ALL_OPEN_INBOUND_PORTS_SECURITY_GROUP_CHECK | Resource Type: | NEW_FINDING | +| | | AWS::EC2::SecurityGroup | | +| | | sg-00003 | | +| 111111111111 | S3_BUCKET_LOGGING_ENABLED | Resource Type: AWS::S3::Bucket | NEW_FINDING | +| | | dig-log-bucket-nonprod-222222222222 | | +`, + }, + { + name: "returnEmptyMDTable#4", + report: &ConfigReport{}, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | NAME | FLAGGED RESOURCES | COMMENTS | +|------------|------|-------------------|----------| +`, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + output := tc.report.toTable(tc.tableType) + assert.Equal(t, tc.expectedOutput, output) + }) + } +} + +func TestInspectorTableOutput(t *testing.T) { + testCases := []struct { + name string + reports *InspectorReports + tableType string + expectedOutput string + expectedOutput2 string + }{ + { + name: "returnPopulatedTables#1", + reports: &InspectorReports{ + Reports: []inspectorReport{ + { + AccountID: "111111111111", + TemplateName: "k8s_weekly_scan", + Findings: []inspectorReportFinding{ + { + RulePackageName: "CIS Operating System Security Configuration Benchmarks-1.0", + High: "2581", + Medium: "0", + Low: "0", + Informational: "232", + Comments: "**EXCEPTION:** Description here", + }, + { + RulePackageName: "Common Vulnerabilities and Exposures-1.1", + High: "29", + Medium: "46", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Runtime Behavior Analysis-1.0", + High: "0", + Medium: "0", + Low: "23", + Informational: "44", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Security Best Practices-1.0", + High: "0", + Medium: "0", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + }, + AMI: map[string]int{ + "TEST_AMI": 65, + "TEST_AMI_2": 30, + }, + }, + }, + }, + tableType: tableTypeNormal, + expectedOutput: `+--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| ACCOUNT ID | TEMPLATE NAME | RULE PACKAGES | HIGH | MEDIUM | LOW | INFORMATIONAL | COMMENTS | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| 111111111111 | k8s_weekly_scan | CIS Operating System Security | 2581 | 0 | 0 | 232 | **EXCEPTION:** Description | +| | | Configuration Benchmarks-1.0 | | | | | here | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| 111111111111 | k8s_weekly_scan | Common Vulnerabilities and | 29 | 46 | 0 | 0 | NEW_FINDING | +| | | Exposures-1.1 | | | | | | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| 111111111111 | k8s_weekly_scan | Runtime Behavior Analysis-1.0 | 0 | 0 | 23 | 44 | NEW_FINDING | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| 111111111111 | k8s_weekly_scan | Security Best Practices-1.0 | 0 | 0 | 0 | 0 | NEW_FINDING | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ ++--------------+------------+---------+ +| ACCOUNT ID | AMI | AGE | ++--------------+------------+---------+ +| 111111111111 | TEST_AMI | 65 days | ++ +------------+---------+ +| | TEST_AMI_2 | 30 days | ++--------------+------------+---------+ +`, + expectedOutput2: `+--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| ACCOUNT ID | TEMPLATE NAME | RULE PACKAGES | HIGH | MEDIUM | LOW | INFORMATIONAL | COMMENTS | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| 111111111111 | k8s_weekly_scan | CIS Operating System Security | 2581 | 0 | 0 | 232 | **EXCEPTION:** Description | +| | | Configuration Benchmarks-1.0 | | | | | here | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| 111111111111 | k8s_weekly_scan | Common Vulnerabilities and | 29 | 46 | 0 | 0 | NEW_FINDING | +| | | Exposures-1.1 | | | | | | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| 111111111111 | k8s_weekly_scan | Runtime Behavior Analysis-1.0 | 0 | 0 | 23 | 44 | NEW_FINDING | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ +| 111111111111 | k8s_weekly_scan | Security Best Practices-1.0 | 0 | 0 | 0 | 0 | NEW_FINDING | ++--------------+-----------------+--------------------------------+------+--------+-----+---------------+--------------------------------+ ++--------------+------------+---------+ +| ACCOUNT ID | AMI | AGE | ++--------------+------------+---------+ +| 111111111111 | TEST_AMI_2 | 30 days | ++ +------------+---------+ +| | TEST_AMI | 65 days | ++--------------+------------+---------+ +`, + }, + { + name: "returnEmptyTables#2", + reports: &InspectorReports{}, + tableType: tableTypeNormal, + expectedOutput: `+------------+---------------+---------------+------+--------+-----+---------------+----------+ +| ACCOUNT ID | TEMPLATE NAME | RULE PACKAGES | HIGH | MEDIUM | LOW | INFORMATIONAL | COMMENTS | ++------------+---------------+---------------+------+--------+-----+---------------+----------+ ++------------+-----+-----+ +| ACCOUNT ID | AMI | AGE | ++------------+-----+-----+ ++------------+-----+-----+ +`, + }, + { + name: "returnPopulatedMDTables#3", + reports: &InspectorReports{ + Reports: []inspectorReport{ + { + AccountID: "111111111111", + TemplateName: "k8s_weekly_scan", + Findings: []inspectorReportFinding{ + { + RulePackageName: "CIS Operating System Security Configuration Benchmarks-1.0", + High: "2581", + Medium: "0", + Low: "0", + Informational: "232", + Comments: "**EXCEPTION:** Description here", + }, + { + RulePackageName: "Common Vulnerabilities and Exposures-1.1", + High: "29", + Medium: "46", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Runtime Behavior Analysis-1.0", + High: "0", + Medium: "0", + Low: "23", + Informational: "44", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Security Best Practices-1.0", + High: "0", + Medium: "0", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + }, + AMI: map[string]int{ + "TEST_AMI": 65, + }, + }, + { + AccountID: "111111111111", + TemplateName: "test_scan", + Findings: []inspectorReportFinding{ + { + RulePackageName: "CIS Operating System Security Configuration Benchmarks-1.0", + High: "123", + Medium: "0", + Low: "0", + Informational: "232", + Comments: "**EXCEPTION:** Description here", + }, + { + RulePackageName: "Common Vulnerabilities and Exposures-1.1", + High: "7", + Medium: "50", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Runtime Behavior Analysis-1.0", + High: "0", + Medium: "0", + Low: "60", + Informational: "45", + Comments: "NEW_FINDING", + }, + { + RulePackageName: "Security Best Practices-1.0", + High: "0", + Medium: "0", + Low: "0", + Informational: "0", + Comments: "NEW_FINDING", + }, + }, + AMI: map[string]int{ + "TEST_AMI": 65, + }, + }, + }, + }, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | TEMPLATE NAME | RULE PACKAGES | HIGH | MEDIUM | LOW | INFORMATIONAL | COMMENTS | +|--------------|-----------------|--------------------------------|------|--------|-----|---------------|--------------------------------| +| 111111111111 | k8s_weekly_scan | CIS Operating System Security | 2581 | 0 | 0 | 232 | **EXCEPTION:** Description | +| | | Configuration Benchmarks-1.0 | | | | | here | +| 111111111111 | k8s_weekly_scan | Common Vulnerabilities and | 29 | 46 | 0 | 0 | NEW_FINDING | +| | | Exposures-1.1 | | | | | | +| 111111111111 | k8s_weekly_scan | Runtime Behavior Analysis-1.0 | 0 | 0 | 23 | 44 | NEW_FINDING | +| 111111111111 | k8s_weekly_scan | Security Best Practices-1.0 | 0 | 0 | 0 | 0 | NEW_FINDING | +| 111111111111 | test_scan | CIS Operating System Security | 123 | 0 | 0 | 232 | **EXCEPTION:** Description | +| | | Configuration Benchmarks-1.0 | | | | | here | +| 111111111111 | test_scan | Common Vulnerabilities and | 7 | 50 | 0 | 0 | NEW_FINDING | +| | | Exposures-1.1 | | | | | | +| 111111111111 | test_scan | Runtime Behavior Analysis-1.0 | 0 | 0 | 60 | 45 | NEW_FINDING | +| 111111111111 | test_scan | Security Best Practices-1.0 | 0 | 0 | 0 | 0 | NEW_FINDING | +| ACCOUNT ID | AMI | AGE | +|--------------|----------|---------| +| 111111111111 | TEST_AMI | 65 days | +| | | | +`, + }, + { + name: "returnEmptyMDTables#4", + reports: &InspectorReports{}, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | TEMPLATE NAME | RULE PACKAGES | HIGH | MEDIUM | LOW | INFORMATIONAL | COMMENTS | +|------------|---------------|---------------|------|--------|-----|---------------|----------| +| ACCOUNT ID | AMI | AGE | +|------------|-----|-----| +`, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + output := tc.reports.toTable(tc.tableType) + assert.Contains(t, []string{tc.expectedOutput, tc.expectedOutput2}, output) + }) + } +} + +func TestHealthTableOutput(t *testing.T) { + testCases := []struct { + name string + report *HealthReport + tableType string + expectedOutput string + }{ + { + name: "returnPopulatedTable#1", + report: &HealthReport{ + Findings: []healthReportFinding{ + { + AccountID: "111111111111", + AffectedEntities: []string{"the-entity-0"}, + Arn: "arn1", + Comments: "**EXCEPTION:** Description", + EventTypeCode: "Rds Security Notification", + LastUpdatedTime: "0001-01-01 00:00:00 +0000 UTC", + Region: "us-east-2", + StatusCode: "open", + EventDescription: "description", + }, + { + AccountID: "111111111111", + AffectedEntities: []string{ + "a-entity-0", + "a-entity-1", + "a-entity-3", + "a-entity-4", + }, + Arn: "arn1", + Comments: "**EXCEPTION:** Description", + EventTypeCode: "Rds Security Notification", + LastUpdatedTime: "0001-01-01 00:00:00 +0000 UTC", + Region: "us-east-2", + StatusCode: "open", + EventDescription: "description", + }, + { + AccountID: "111111111111", + AffectedEntities: []string{ + "some-entity-0", + "some-entity-1", + }, + Arn: "arn1", + Comments: "NEW_FINDING", + EventTypeCode: "Rds Operational Notification", + LastUpdatedTime: "0001-01-01 00:00:00 +0000 UTC", + Region: "us-east-2", + StatusCode: "open", + EventDescription: "description", + }, + }, + }, + tableType: tableTypeNormal, + expectedOutput: `+--------------+------------------------------+-----------+-------------+-------------------+--------------------------------+----------------------------+ +| ACCOUNT ID | EVENT TYPE CODE | REGION | STATUS CODE | EVENT DESCRIPTION | AFFECTED RESOURCES | COMMENTS | ++--------------+------------------------------+-----------+-------------+-------------------+--------------------------------+----------------------------+ +| 111111111111 | Rds Security Notification | us-east-2 | open | description | the-entity-0 | **EXCEPTION:** Description | ++--------------+------------------------------+-----------+-------------+-------------------+--------------------------------+----------------------------+ +| 111111111111 | Rds Security Notification | us-east-2 | open | description | a-entity-0, a-entity-1, | **EXCEPTION:** Description | +| | | | | | a-entity-3, a-entity-4 | | ++--------------+------------------------------+-----------+-------------+-------------------+--------------------------------+----------------------------+ +| 111111111111 | Rds Operational Notification | us-east-2 | open | description | some-entity-0, some-entity-1 | NEW_FINDING | ++--------------+------------------------------+-----------+-------------+-------------------+--------------------------------+----------------------------+ +`, + }, + { + name: "returnEmptyTable#2", + report: &HealthReport{}, + tableType: tableTypeNormal, + expectedOutput: `+------------+-----------------+--------+-------------+-------------------+--------------------+----------+ +| ACCOUNT ID | EVENT TYPE CODE | REGION | STATUS CODE | EVENT DESCRIPTION | AFFECTED RESOURCES | COMMENTS | ++------------+-----------------+--------+-------------+-------------------+--------------------+----------+ +`, + }, + { + name: "returnPopulatedMDTable#3", + report: &HealthReport{ + Findings: []healthReportFinding{ + { + AccountID: "111111111111", + AffectedEntities: []string{"the-entity-0"}, + Arn: "arn1", + Comments: "**EXCEPTION:** Description", + EventTypeCode: "Rds Security Notification", + LastUpdatedTime: "0001-01-01 00:00:00 +0000 UTC", + Region: "us-east-2", + StatusCode: "open", + EventDescription: "description", + }, + { + AccountID: "111111111111", + AffectedEntities: []string{ + "a-entity-0", + "a-entity-1", + "a-entity-3", + "a-entity-4", + }, + Arn: "arn1", + Comments: "**EXCEPTION:** Description", + EventTypeCode: "Rds Security Notification", + LastUpdatedTime: "0001-01-01 00:00:00 +0000 UTC", + Region: "us-east-2", + StatusCode: "open", + EventDescription: "description", + }, + { + AccountID: "111111111111", + AffectedEntities: []string{ + "some-entity-0", + "some-entity-1", + }, + Arn: "arn1", + Comments: "NEW_FINDING", + EventTypeCode: "Rds Operational Notification", + LastUpdatedTime: "0001-01-01 00:00:00 +0000 UTC", + Region: "us-east-2", + StatusCode: "open", + EventDescription: "description", + }, + }, + }, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | EVENT TYPE CODE | REGION | STATUS CODE | EVENT DESCRIPTION | AFFECTED RESOURCES | COMMENTS | +|--------------|------------------------------|-----------|-------------|-------------------|--------------------------------|----------------------------| +| 111111111111 | Rds Security Notification | us-east-2 | open | description | the-entity-0 | **EXCEPTION:** Description | +| 111111111111 | Rds Security Notification | us-east-2 | open | description | a-entity-0, a-entity-1, | **EXCEPTION:** Description | +| | | | | | a-entity-3, a-entity-4 | | +| 111111111111 | Rds Operational Notification | us-east-2 | open | description | some-entity-0, some-entity-1 | NEW_FINDING | +`, + }, + { + name: "returnEmptyMDTable#4", + report: &HealthReport{}, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | EVENT TYPE CODE | REGION | STATUS CODE | EVENT DESCRIPTION | AFFECTED RESOURCES | COMMENTS | +|------------|-----------------|--------|-------------|-------------------|--------------------|----------| +`, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + output := tc.report.toTable(tc.tableType) + assert.Equal(t, tc.expectedOutput, output) + }) + } +} + +func TestReflectReportTableOutput(t *testing.T) { + testCases := []struct { + name string + report *ReflectReport + tableType string + expectedOutput string + }{ + { + name: "returnPopulatedTable#1", + report: &ReflectReport{ + Findings: []reflectFinding{ + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass", + AccessDetails: []accessDetails{ + {"sts.amazonaws.com/AssumeRole", 15}, + {"sts.amazonaws.com/AssumeRole/AccessDenied", 15}, + }, + PermissionSet: []string{"kms:ListKeys", "kms:ListGrants", "kms:GenerateDataKeyWithoutPlaintext"}, + Comments: "**EXCEPTION:** I am too tired to write a test case", + }, + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{ + {"iam.amazonaws.com/UpdateAssumeRolePolicy", 1}, + {"iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied", 1}, + }, + PermissionSet: []string{"kms:Encrypt", "kms:DescribeKey"}, + Comments: "NEW_FINDING", + }, + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{}, + PermissionSet: []string{"kms:Encrypt", "kms:DescribeKey"}, + Comments: "**EXCEPTION:** lets get this over with!", + }, + }, + }, + tableType: tableTypeNormal, + expectedOutput: `+--------------+------------------------------------------------------------+---------------------------------------------------------+-------------------------------------+--------------------------------+ +| ACCOUNT ID | IAM IDENTITY | ACCESS DETAILS | ACTUAL PERMISSIONS | COMMENTS | ++--------------+------------------------------------------------------------+---------------------------------------------------------+-------------------------------------+--------------------------------+ +| 111111111111 | arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass | sts.amazonaws.com/AssumeRole:15 | kms:ListKeys kms:ListGrants | **EXCEPTION:** I am too tired | +| | | sts.amazonaws.com/AssumeRole/AccessDenied:15 | kms:GenerateDataKeyWithoutPlaintext | to write a test case | ++--------------+------------------------------------------------------------+---------------------------------------------------------+-------------------------------------+--------------------------------+ +| 111111111111 | arn:aws:iam::111111111111:role/AWS_111111111111_Read | iam.amazonaws.com/UpdateAssumeRolePolicy:1 | kms:Encrypt | NEW_FINDING | +| | | iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied:1 | kms:DescribeKey | | ++--------------+------------------------------------------------------------+---------------------------------------------------------+-------------------------------------+--------------------------------+ +| 111111111111 | arn:aws:iam::111111111111:role/AWS_111111111111_Read | | kms:Encrypt | **EXCEPTION:** lets get this | +| | | | kms:DescribeKey | over with! | ++--------------+------------------------------------------------------------+---------------------------------------------------------+-------------------------------------+--------------------------------+ +`, + }, + { + name: "returnPopulatedMDTable#2", + report: &ReflectReport{ + Findings: []reflectFinding{ + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass", + AccessDetails: []accessDetails{ + {"sts.amazonaws.com/AssumeRole", 15}, + {"sts.amazonaws.com/AssumeRole/AccessDenied", 15}, + }, + PermissionSet: []string{"kms:ListKeys", "kms:ListGrants", "kms:GenerateDataKeyWithoutPlaintext"}, + Comments: "**EXCEPTION:** I am too tired to write a test case", + }, + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{ + {"iam.amazonaws.com/UpdateAssumeRolePolicy", 1}, + {"iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied", 1}, + }, + PermissionSet: []string{"kms:Encrypt", "kms:DescribeKey"}, + Comments: "NEW_FINDING", + }, + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{}, + PermissionSet: []string{"kms:Encrypt", "kms:DescribeKey"}, + Comments: "**EXCEPTION:** lets get this over with!", + }, + }, + }, + tableType: tableTypeMD, + expectedOutput: `| ACCOUNT ID | IAM IDENTITY | ACCESS DETAILS | ACTUAL PERMISSIONS | COMMENTS | +|--------------|------------------------------------------------------------|---------------------------------------------------------|-------------------------------------|--------------------------------| +| 111111111111 | arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass | sts.amazonaws.com/AssumeRole:15 | kms:ListKeys kms:ListGrants | **EXCEPTION:** I am too tired | +| | | sts.amazonaws.com/AssumeRole/AccessDenied:15 | kms:GenerateDataKeyWithoutPlaintext | to write a test case | +| 111111111111 | arn:aws:iam::111111111111:role/AWS_111111111111_Read | iam.amazonaws.com/UpdateAssumeRolePolicy:1 | kms:Encrypt | NEW_FINDING | +| | | iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied:1 | kms:DescribeKey | | +| 111111111111 | arn:aws:iam::111111111111:role/AWS_111111111111_Read | | kms:Encrypt | **EXCEPTION:** lets get this | +| | | | kms:DescribeKey | over with! | +`, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + output := tc.report.toTable(tc.tableType) + assert.Equal(t, tc.expectedOutput, output) + }) + } +} diff --git a/pkg/cloudig/reflect.go b/pkg/cloudig/reflect.go new file mode 100644 index 0000000..7a28336 --- /dev/null +++ b/pkg/cloudig/reflect.go @@ -0,0 +1,563 @@ +package cloudig + +import ( + "bytes" + "fmt" + "os" + "sort" + "strconv" + "strings" + "sync" + "text/template" + "time" + + awslocal "github.com/Optum/cloudig/pkg/aws" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/endpoints" + "github.com/aws/aws-sdk-go/service/athena" + "github.com/kris-nova/logger" +) + +const ( + queryForUsage string = "QU" + queryForErrors string = "QE" + identityDelimiter string = "@" + keyIdentityARN string = "identity_arn" + keyErrorCode string = "errorcode" + keyEventSource string = "eventsource" + keyEventName string = "eventname" + keyARN string = "arn" + keyCount string = "count" +) + +// ReflectReport is struct that contains a slice of Reflect findings +type ReflectReport struct { + Findings []reflectFinding `json:"findings"` + Flags ReflectFlags `json:"-"` // hide in json output + jsonOutputHelper +} + +type reflectFinding struct { + AccountID string `json:"accountId"` + Identity string `json:"IAMIdentity"` + AccessDetails []accessDetails `json:"accessDetails"` + PermissionSet []string `json:"permissionSet"` + Comments string `json:"comments"` +} + +type accessDetails struct { + Event string `json:"IAMAction"` + Count int `json:"UsageCount"` +} + +// ReflectFlags provides a collection of different flags for various stages of handling requests +type ReflectFlags struct { + region string + roles []string + roleTags map[string]string + usageReport bool + errorReport bool + includeUserIdentity bool + absoluteTime string + relativeTime int +} + +// NewReflectFlags returns a new instance Reflectflag +func NewReflectFlags(region string, roles []string, roleTags map[string]string, usageReport, errorReport, includeIdentity bool, absTime string, relTime int) ReflectFlags { + return ReflectFlags{ + region: region, + roles: roles, + roleTags: roleTags, + usageReport: usageReport, + errorReport: errorReport, + includeUserIdentity: includeIdentity, + absoluteTime: absTime, + relativeTime: relTime, + } +} + +type runQueryResult struct { + result *athena.ResultSet + err error +} + +// GetReport retrives the reflect report for a given account +func (report *ReflectReport) GetReport(client awslocal.APIs, comments []Comments) error { + start := time.Now() + flags := report.Flags + accountID, err := client.GetAccountID() + if err != nil { + return err + } + logger.Info("working on reflect report for account: %s", accountID) + + logger.Info("getting the s3 prefix associated with the CloudTrail for account: %s", accountID) + // get S3 bucket with prefix associated with CloudTrail + s3Prefix, err := client.GetS3LogPrefixForCloudTrail() + if err != nil { + return err + } + + if s3Prefix == nil { + return fmt.Errorf("Either Cloudtrail is not enabled or doesn't have an S3 bucket associated in account: %s", accountID) + } + + logger.Debug("retrieving the list of AWS regions") + regionList := make([]string, 0) + for _, p := range endpoints.DefaultPartitions() { + for region := range p.Regions() { + regionList = append(regionList, region) + } + } + // Consistent ordering avoids creating table due to metadata mismatch + sort.Strings(regionList) + + logger.Info("constructing the Athena table metadata form the s3 prefix for account: %s", accountID) + // construct Athena table metadata from s3 location + meta := awslocal.NewAthenaTableMetaDataForCloudTrail(aws.StringValue(s3Prefix), regionList) + + // get existing or new table name + logger.Info("finding the existing Athena table from the constructed metadata for account: %s", accountID) + tableName, err := client.GetTableforMetadata(meta) + if err != nil { + logger.Warning("error getting the existing valid Athena table from the account %s: %s", accountID, err.Error()) + } + if tableName == nil { + logger.Warning("could not get valid Athena table from the account %s", accountID) + logger.Info("creating new Athena table in account: %s", accountID) + tableName, err = client.CreateTableFromMetadata(meta) + if err != nil { + logger.Critical("error creating Athena table in account: %s : %v", accountID, err) + return err + } + } else { + logger.Info("found the existing Athena table: %s for account: %s", aws.StringValue(tableName), accountID) + } + targetedRoles := make([]string, 0) + // Update roles if roles from Flags are empty but roleTags are provided + if len(flags.roles) == 0 { + // if RoleTags are also empty, we do nothing here + if len(flags.roleTags) > 0 { + // list all roles with a specific set of tags + logger.Info("getting the roles from tags: %v for account: %s", flags.roleTags, accountID) + roles, err := client.GetRolesFromTags(flags.roleTags) + if err != nil { + logger.Info("could not get roles from tags for account: %s : %v", accountID, err) + } else { + logger.Debug("list of roles from tags %v: %v for account: %s", flags.roleTags, roles, accountID) + if len(roles) == 0 { + return fmt.Errorf("no roles found for the given set of tags %v in account: %s", flags.roleTags, accountID) + } + targetedRoles = roles + flags.roles = targetedRoles + } + } + } else { + targetedRoles = flags.roles + } + + // polpulate the findings for a given roles + logger.Info("populating findings for roles in account: %s", accountID) + findings, err := populateFindings(client, aws.StringValue(tableName), flags) + if err != nil { + return err + } + logger.Success("successfully populated the findings for roles in account: %s", accountID) + + permissionForRoles := make(map[string][]string) + + // Populate the actual permissions for the targated roles. targeted roles are the once provided by the user, + // if none provided, actual permsions are retrived for every role in the findings + if len(targetedRoles) == 0 { + for _, v := range findings { + targetedRoles = append(targetedRoles, strings.Split(v.Identity, identityDelimiter)[0]) + } + } + logger.Debug("targeted roles are %v", targetedRoles) + logger.Info("finding the actual permission for the roles in account: %s", accountID) + permissionForRoles = client.GetNetIAMPermissionsForRoles(targetedRoles) + + // loop through all findings to add comments and policy actions + for k, v := range findings { + findings[k].AccountID = accountID + findings[k].PermissionSet = permissionForRoles[strings.Split(v.Identity, identityDelimiter)[0]] + findings[k].Comments = getComments(comments, accountID, findingTypeReflectIAM, v.Identity) + } + report.Findings = append(report.Findings, findings...) + logger.Success("reflecting on account %s took %s", accountID, time.Since(start)) + return nil +} + +func populateFindings(client awslocal.APIs, tableName string, flags ReflectFlags) ([]reflectFinding, error) { + var wg sync.WaitGroup + findings := make([]reflectFinding, 0) + output := make(chan runQueryResult, 2) + + if flags.usageReport { + logger.Debug("reflecting on usage report") + wg.Add(1) + // Run query - 1 + go func() { + defer wg.Done() + resultSetUsage, err := client.RunQuery(tableName, createQueryFromFlags(flags, tableName, queryForUsage)) + output <- runQueryResult{result: resultSetUsage, err: err} + }() + } + + if flags.errorReport { + logger.Debug("reflecting on error report") + wg.Add(1) + // Run Query - 2 + go func() { + defer wg.Done() + resultSetError, err := client.RunQuery(tableName, createQueryFromFlags(flags, tableName, queryForErrors)) + output <- runQueryResult{result: resultSetError, err: err} + }() + } + + // lets run this in background to close the chanel once all background routines are complete + go func() { + wg.Wait() + close(output) + }() + + keys := make([]string, 0) + dataSlice := make([]string, 0) + for v := range output { + if v.err != nil { + return findings, v.err + } + for k, v := range v.result.Rows { + if k == 0 { + for _, v1 := range v.Data { + keys = append(keys, aws.StringValue(v1.VarCharValue)) + } + continue + } + for _, v2 := range v.Data { + dataSlice = append(dataSlice, aws.StringValue(v2.VarCharValue)) + } + ide, acc := constructFinding(dataSlice, keys) + updateFinding(flags, &findings, ide, acc) + dataSlice = nil + } + keys = nil + } + return findings, nil +} + +// create or update finding +func updateFinding(flags ReflectFlags, findings *[]reflectFinding, identity string, eventD accessDetails) { + // Filterting of the results come into play only when number of roles are > 1 + // when no roles are provided, all results are returned + // when a single role is provided , query is designed to return result for single role + if len(flags.roles) > 1 { + if !Contains(flags.roles, strings.Split(identity, identityDelimiter)[0]) { + return + } + } + + found := false + // add to accessDetails if Identity is already in the slice + for k, v := range *findings { + if v.Identity == identity { + for adk, adv := range v.AccessDetails { + if adv.Event == eventD.Event { + v.AccessDetails[adk].Count = adv.Count + eventD.Count + found = true + return + } + } + + (*findings)[k] = reflectFinding{ + Identity: identity, + AccessDetails: append(v.AccessDetails, eventD), + } + found = true + break + } + } + // add new finding if identity is not found in the slice + if !found { + ed := make([]accessDetails, 0) + *findings = append(*findings, reflectFinding{ + Identity: identity, + AccessDetails: append(ed, eventD), + }) + } +} + +// constructFinding is a helper function that transforms a row of the query output to finding based on row header(keys) +func constructFinding(dataSlice, keys []string) (string, accessDetails) { + eventD := accessDetails{} + var identity string + var hasErrorCode, hasIdentity bool + indexMap := make(map[string]int) + for k, v := range keys { + indexMap[v] = k + if v == keyIdentityARN { + hasIdentity = true + } + if v == keyErrorCode { + hasErrorCode = true + } + } + + if hasIdentity { + ss := strings.Split(dataSlice[indexMap[keyIdentityARN]], "/") + identity = dataSlice[indexMap[keyARN]] + identityDelimiter + ss[len(ss)-1] + } else { + identity = dataSlice[indexMap[keyARN]] + } + + if hasErrorCode { + eventD.Event = dataSlice[indexMap[keyEventSource]] + "/" + dataSlice[indexMap[keyEventName]] + "/" + dataSlice[indexMap[keyErrorCode]] + } else { + eventD.Event = dataSlice[indexMap[keyEventSource]] + "/" + dataSlice[indexMap[keyEventName]] + } + count, err := strconv.Atoi(dataSlice[indexMap[keyCount]]) + if err != nil { + logger.Critical("error converting count value from string '%s' to int: %v", dataSlice[indexMap[keyCount]], err) + eventD.Count = 0 + } else { + eventD.Count = count + } + logger.Debug("constructed finding %s -> %v", identity, eventD) + return identity, eventD +} + +type timeRange struct { + Months []int + Days []int + Years []int + EventTimeRange []string +} + +// createQueryFromFlags construct query from given flags and query type +func createQueryFromFlags(flags ReflectFlags, tableName, queryType string) string { + var timeR timeRange + //var needIdentity bool + var role string + var tpl bytes.Buffer + + // additional identity field is used only if single role is provided + if len(flags.roles) == 1 { + role = flags.roles[0] + } else { + role = "" + } + + // First, examine the timeAbolute,If time timeAbolute is provided, timeRelative is ignored + // format of timeAbolute (mm/dd/yyyy-mm/dd/yyyy) is assumed to be accurate as this should be handled in the CLI validation + if flags.absoluteTime != "" { + timeR = constructPartitionDataFromTime(flags.absoluteTime) + // If time timeAbolute is not provided, timeRelative is used + // format of timeRelative (day int) is assumed to be accurate as this should be handled in the CLI validation + } else { + timeR = constructPartitionDataFromTime(getAbsoluteTime(flags.relativeTime, time.Now())) + } + + queryData := struct { + TableName string + NeedIdentity bool + Region string + Role string + Time timeRange + IdentityARN string + ErrorCode string + EventSource string + EventName string + Count string + }{ + TableName: tableName, + NeedIdentity: flags.includeUserIdentity, + Region: flags.region, + Role: role, + Time: timeR, + IdentityARN: keyIdentityARN, + ErrorCode: keyErrorCode, + EventSource: keyEventSource, + EventName: keyEventName, + Count: keyCount, + } + + if queryType == queryForUsage { + queryString := ` +SELECT useridentity.sessioncontext.sessionissuer.arn,{{ if .NeedIdentity }}useridentity.arn AS {{.IdentityARN}},{{end}}{{.EventSource}},{{.EventName}},count({{.EventName}}) AS {{.Count}} +FROM {{.TableName}} +WHERE region='{{.Region}}' + AND year IN ({{ $first := true }}{{ range $v := .Time.Years }}{{if $first }}{{$first = false }}{{else}},{{ end -}} '{{ $v}}'{{ end }}) + AND month IN ({{ $first := true }}{{ range $v := .Time.Months}}{{if $first }}{{$first = false }}{{else}},{{ end -}} '{{printf "%02d" $v}}'{{ end }}) + AND day IN ({{ $first := true }}{{ range $v := .Time.Days}}{{if $first }}{{$first = false }}{{else}},{{ end -}} '{{printf "%02d" $v}}'{{ end }}) + AND eventtime >= '{{index .Time.EventTimeRange 0}}' + AND eventtime <= '{{index .Time.EventTimeRange 1}}'{{if ne .Role ""}} + AND useridentity.sessioncontext.sessionissuer.arn LIKE '{{.Role}}'{{ end }} +GROUP BY useridentity.arn,{{.EventSource}},{{.EventName}},useridentity.sessioncontext.sessionissuer.arn +ORDER BY useridentity.arn,{{.Count}} DESC +` + t := template.Must(template.New("").Parse(queryString)) + err := t.Execute(&tpl, queryData) + if err != nil { + logger.Critical("error constructing the usage Athena query: %v", err) + os.Exit(1) // intentional + } + } else if queryType == queryForErrors { + queryString := ` +SELECT useridentity.sessioncontext.sessionissuer.arn,{{ if .NeedIdentity }}useridentity.arn AS {{.IdentityARN}},{{end}}{{.EventSource}},{{.EventName}},{{.ErrorCode}},count(useridentity.sessioncontext.sessionissuer.arn) AS {{.Count}} +FROM {{.TableName}} +WHERE region='{{.Region}}' + AND year IN ({{ $first := true }}{{ range $v := .Time.Years}}{{if $first}}{{$first = false}}{{else}},{{ end -}}'{{ $v}}'{{ end }}) + AND month IN ({{ $first := true }}{{ range $v := .Time.Months}}{{if $first}}{{$first = false}}{{else}},{{ end -}}'{{printf "%02d" $v}}'{{ end }}) + AND day IN ({{ $first := true }}{{ range $v := .Time.Days}}{{if $first}}{{$first = false}}{{else}},{{ end -}}'{{printf "%02d" $v}}'{{ end }}) + AND eventtime >= '{{index .Time.EventTimeRange 0}}' + AND eventtime <= '{{index .Time.EventTimeRange 1}}' + AND useridentity.arn != ''{{ if ne .Role ""}} + AND useridentity.sessioncontext.sessionissuer.arn LIKE '{{.Role}}'{{ end }} + AND ({{.ErrorCode}} LIKE '%UnauthorizedOperation' OR {{.ErrorCode}} LIKE 'AccessDenied%') +GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,{{.EventSource}},{{.EventName}},{{.ErrorCode}} +ORDER BY useridentity.arn,{{.Count}} DESC +` + t := template.Must(template.New("").Parse(queryString)) + err := t.Execute(&tpl, queryData) + if err != nil { + logger.Critical("error constructing the error Athena query: %v", err) + os.Exit(1) // intentional + } + } + query := tpl.String() + // Be aware of this for https://github.com/kris-nova/logger/pull/4 + // AND (errorcode LIKE '%!U(MISSING)nauthorizedOperation' OR errorcode LIKE 'AccessDenied%!'(MISSING)) + logger.Debug("constructred query: %s", query) + return query +} + +// getAbsoluteTime is helper function to covert relative time to absolute time +func getAbsoluteTime(timeRelative int, now time.Time) string { + var startTime, endTime time.Time + if timeRelative != 0 { + endTime = now + startTime = endTime.AddDate(0, 0, -timeRelative) + } else { + endTime = now + startTime = now + } + y1, m1, d1 := startTime.Date() + y2, m2, d2 := endTime.Date() + absTime := fmt.Sprintf("%02d/%02d/%d-%02d/%02d/%d", int(m1), d1, y1, int(m2), d2, y2) + logger.Debug("converted relative time: %d days to absolute time: %s", timeRelative, absTime) + return absTime +} + +// constructPartitionDataFromTime help extract partitions that can be used for the query +func constructPartitionDataFromTime(timeAbsolute string) timeRange { + var startTime, endTime time.Time + dates := strings.Split(timeAbsolute, "-") + startDate, endDate := dates[0], dates[1] + format := "01/02/2006" // mm/dd/yyyy format + var err error + // convert to time + startTime, err = time.Parse(format, startDate) + if err != nil { + logger.Critical("could not parse start time from given abolutetime %s", timeAbsolute) + os.Exit(1) + } + endTime, err = time.Parse(format, endDate) + if err != nil { + logger.Critical("could not parse end time from given abolutetime %s", timeAbsolute) + os.Exit(1) + } + years := make([]int, 0) + months := make([]int, 0) + days := make([]int, 0) + eventTimeRange := make([]string, 0) + + y1, m1, d1 := startTime.Date() + y2, m2, d2 := endTime.Date() + yDif := int(y2 - y1) + mDif := int(m2 - m1) + dDif := int(d2 - d1) + + // Normalize negative values + if dDif < 0 { + // days in month: + t := time.Date(y1, m1, 32, 0, 0, 0, 0, time.UTC) + dDif += 32 - t.Day() + mDif-- + months = append(months, int(m2)) + } + if mDif < 0 { + mDif += 12 + yDif-- + years = append(years, y2) + } + //get the event time range with RFC3339 layout + eventStart := time.Date(y1, m1, d1, 0, 0, 0, 0, time.UTC).Format(time.RFC3339) + eventEnd := time.Date(y2, m2, d2, 23, 59, 59, 999, time.UTC).Format(time.RFC3339) + eventTimeRange = append(eventTimeRange, []string{eventStart, eventEnd}...) + + // lets determine the partitions for the given dates + if yDif > 0 { + for yDif >= 0 { + years = append(years, y1) + y1 = y1 + 1 + yDif-- + } + months = []int{} + for i := 1; i <= 12; i++ { + months = append(months, i) + } + for i := 1; i <= 31; i++ { + days = append(days, i) + } + } else { + years = append(years, y1) + if mDif == 0 { + months = append(months, int(m1)) + + for dDif >= 0 { + days = append(days, d1) + d1 = d1 + 1 + if d1 == 32 { + d1 = 1 + } + dDif-- + } + } else if mDif == 1 { + months = append(months, []int{int(m1), int(m1 + 1)}...) + if dDif >= 29 || dDif == 0 { + for i := 1; i <= 31; i++ { + days = append(days, i) + } + } else { + for dDif > 0 { + days = append(days, d1) + if d1 == d2 { + break + } + d1 = d1 + 1 + if d1 == 32 { + d1 = 1 + } + dDif-- + } + } + } else { + for mDif >= 0 { + months = append(months, int(m1)) + m1 = m1 + 1 + if m1 == 13 { //can't be 13 + m1 = 1 + } + mDif-- + } + for i := 1; i <= 31; i++ { + days = append(days, i) + } + } + } + sort.Ints(months) + sort.Ints(days) + sort.Ints(years) + logger.Debug("converted partition data from absolute time: %s is %v", timeAbsolute, timeRange{months, days, years, eventTimeRange}) + return timeRange{months, days, years, eventTimeRange} +} diff --git a/pkg/cloudig/reflect_test.go b/pkg/cloudig/reflect_test.go new file mode 100644 index 0000000..c264d51 --- /dev/null +++ b/pkg/cloudig/reflect_test.go @@ -0,0 +1,1271 @@ +package cloudig + +import ( + "errors" + "reflect" + "testing" + "time" + + "github.com/Optum/cloudig/pkg/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/athena" + "github.com/golang/mock/gomock" + "github.com/kris-nova/logger" +) + +func TestReflectReport_GetReport(t *testing.T) { + // report := ReflectReport{} + // sess, _ := awslocal.NewAuthenticatedSession("us-east-1") + // client := awslocal.NewClient(sess) + // comments := make([]Comments, 0) + // err := report.GetReport(client, &comments) + // if err != nil { + // log.Println(err) + // } + // t.Fail() + athenaResultSetUsage := &athena.ResultSet{ + ResultSetMetadata: &athena.ResultSetMetadata{ColumnInfo: []*athena.ColumnInfo{ + { + Name: aws.String("arn"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventsource"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventname"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("count"), + Type: aws.String("varchar"), + }, + }}, + Rows: []*athena.Row{ + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn")}, + {VarCharValue: aws.String("eventsource")}, + {VarCharValue: aws.String("eventname")}, + {VarCharValue: aws.String("count")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_Read")}, + {VarCharValue: aws.String("iam.amazonaws.com")}, + {VarCharValue: aws.String("UpdateAssumeRolePolicy")}, + {VarCharValue: aws.String("1")}, + }, + }, + }, + } + + athenaResultSetError := &athena.ResultSet{ + ResultSetMetadata: &athena.ResultSetMetadata{ColumnInfo: []*athena.ColumnInfo{ + { + Name: aws.String("arn"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventsource"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventname"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("errorcode"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("count"), + Type: aws.String("varchar"), + }, + }}, + Rows: []*athena.Row{ + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn")}, + {VarCharValue: aws.String("eventsource")}, + {VarCharValue: aws.String("eventname")}, + {VarCharValue: aws.String("errorcode")}, + {VarCharValue: aws.String("count")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_Read")}, + {VarCharValue: aws.String("iam.amazonaws.com")}, + {VarCharValue: aws.String("UpdateAssumeRolePolicy")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("1")}, + }, + }, + }, + } + + type args struct { + comments []Comments + } + tests := []struct { + name string + args args + initFindings []reflectFinding + flags ReflectFlags + mockedGetS3LogPrefixForCloudTrailResponse *string + mockedGetS3LogPrefixForCloudTrailError error + mockedGetTableforMetadataResponse *string + mockedGetTableforMetadataError error + mockedCreateTableFromMetadataResponse *string + mockedCreateTableFromMetadataError error + GetRolesFromTagsResponse []string + GetRolesFromTagsError error + mockedUsageReportRunQueryResponse *athena.ResultSet + mockedErrorReportRunQueryResponse *athena.ResultSet + mockedUsageReportRunQueryError error + mockedErrorReportRunQueryError error + GetNetIAMPermissionsForRolesResponse map[string][]string + updatedFindings []reflectFinding + wantErr bool + }{ + { + name: "s3LogPrefixFailure#1", + args: args{ + []Comments{}, + }, + initFindings: []reflectFinding{}, + flags: NewReflectFlags("us-east-1", []string{"arn:aws:iam::111111111111:role/AWS_111111111111_Read"}, map[string]string{}, true, true, false, "", 1), + mockedGetS3LogPrefixForCloudTrailResponse: nil, + mockedGetS3LogPrefixForCloudTrailError: errors.New("some error"), + mockedGetTableforMetadataResponse: nil, + mockedGetTableforMetadataError: nil, + mockedCreateTableFromMetadataResponse: nil, + mockedCreateTableFromMetadataError: nil, + GetRolesFromTagsResponse: nil, + GetRolesFromTagsError: nil, + mockedUsageReportRunQueryResponse: &athena.ResultSet{}, + mockedErrorReportRunQueryResponse: &athena.ResultSet{}, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + GetNetIAMPermissionsForRolesResponse: map[string][]string{}, + updatedFindings: []reflectFinding{}, + wantErr: true, + }, + { + name: "s3LogPrefixEmpty#2", + args: args{ + []Comments{}, + }, + initFindings: []reflectFinding{}, + flags: NewReflectFlags("us-east-1", []string{"arn:aws:iam::111111111111:role/AWS_111111111111_Read"}, map[string]string{}, true, true, false, "", 1), + mockedGetS3LogPrefixForCloudTrailResponse: nil, + mockedGetS3LogPrefixForCloudTrailError: nil, + mockedGetTableforMetadataResponse: nil, + mockedGetTableforMetadataError: nil, + mockedCreateTableFromMetadataResponse: nil, + mockedCreateTableFromMetadataError: nil, + GetRolesFromTagsResponse: nil, + GetRolesFromTagsError: nil, + mockedUsageReportRunQueryResponse: &athena.ResultSet{}, + mockedErrorReportRunQueryResponse: &athena.ResultSet{}, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + GetNetIAMPermissionsForRolesResponse: map[string][]string{}, + updatedFindings: []reflectFinding{}, + wantErr: true, + }, + { + name: "getExistingTableError#3", + args: args{ + []Comments{}, + }, + initFindings: []reflectFinding{}, + flags: NewReflectFlags("us-east-1", []string{"arn:aws:iam::111111111111:role/AWS_111111111111_Read"}, map[string]string{}, true, true, false, "", 1), + mockedGetS3LogPrefixForCloudTrailResponse: aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + mockedGetS3LogPrefixForCloudTrailError: nil, + mockedGetTableforMetadataResponse: nil, + mockedGetTableforMetadataError: errors.New("some error"), + mockedCreateTableFromMetadataResponse: nil, + mockedCreateTableFromMetadataError: errors.New("some error"), + GetRolesFromTagsResponse: nil, + GetRolesFromTagsError: nil, + mockedUsageReportRunQueryResponse: &athena.ResultSet{}, + mockedErrorReportRunQueryResponse: &athena.ResultSet{}, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + GetNetIAMPermissionsForRolesResponse: map[string][]string{}, + updatedFindings: []reflectFinding{}, + wantErr: true, + }, + { + name: "emptyGetExistingTable#4", + args: args{ + []Comments{}, + }, + initFindings: []reflectFinding{}, + flags: NewReflectFlags("us-east-1", []string{"arn:aws:iam::111111111111:role/AWS_111111111111_Read"}, map[string]string{}, true, true, false, "", 1), + mockedGetS3LogPrefixForCloudTrailResponse: aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + mockedGetS3LogPrefixForCloudTrailError: nil, + mockedGetTableforMetadataResponse: nil, + mockedGetTableforMetadataError: nil, + mockedCreateTableFromMetadataResponse: nil, + mockedCreateTableFromMetadataError: errors.New("some error"), + GetRolesFromTagsResponse: nil, + GetRolesFromTagsError: nil, + mockedUsageReportRunQueryResponse: &athena.ResultSet{}, + mockedErrorReportRunQueryResponse: &athena.ResultSet{}, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + GetNetIAMPermissionsForRolesResponse: map[string][]string{}, + updatedFindings: []reflectFinding{}, + wantErr: true, + }, + { + name: "getExistingTableSuccess#5", + args: args{ + []Comments{}, + }, + initFindings: []reflectFinding{}, + flags: NewReflectFlags("us-east-1", []string{"arn:aws:iam::111111111111:role/AWS_111111111111_Read"}, map[string]string{}, true, true, false, "", 1), + mockedGetS3LogPrefixForCloudTrailResponse: aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + mockedGetS3LogPrefixForCloudTrailError: nil, + mockedGetTableforMetadataResponse: aws.String("default.reflect_cloudtrail_gxev4"), + mockedGetTableforMetadataError: nil, + mockedCreateTableFromMetadataResponse: nil, + mockedCreateTableFromMetadataError: nil, + GetRolesFromTagsResponse: nil, + GetRolesFromTagsError: nil, + mockedUsageReportRunQueryResponse: athenaResultSetUsage, + mockedErrorReportRunQueryResponse: athenaResultSetError, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + GetNetIAMPermissionsForRolesResponse: map[string][]string{}, + updatedFindings: []reflectFinding{ + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{ + {"iam.amazonaws.com/UpdateAssumeRolePolicy", 1}, + {"iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied", 1}, + }, + PermissionSet: nil, + Comments: "NEW_FINDING", + }, + }, + wantErr: false, + }, + { + name: "roleFromTagsSuccess#6", + args: args{ + []Comments{}, + }, + initFindings: []reflectFinding{}, + flags: NewReflectFlags("us-east-1", nil, map[string]string{"myapp": "awesome"}, true, true, false, "", 1), + mockedGetS3LogPrefixForCloudTrailResponse: aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + mockedGetS3LogPrefixForCloudTrailError: nil, + mockedGetTableforMetadataResponse: nil, + mockedGetTableforMetadataError: nil, + mockedCreateTableFromMetadataResponse: aws.String("default.reflect_cloudtrail_gxev4"), + mockedCreateTableFromMetadataError: nil, + GetRolesFromTagsResponse: []string{"arn:aws:iam::111111111111:role/AWS_111111111111_Read"}, + GetRolesFromTagsError: nil, + mockedUsageReportRunQueryResponse: athenaResultSetUsage, + mockedErrorReportRunQueryResponse: athenaResultSetError, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + GetNetIAMPermissionsForRolesResponse: map[string][]string{"arn:aws:iam::111111111111:role/AWS_111111111111_Read": {"iam:UpdateAssumeRolePolicy", "s3:GetObject"}}, + updatedFindings: []reflectFinding{ + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{ + {"iam.amazonaws.com/UpdateAssumeRolePolicy", 1}, + {"iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied", 1}, + }, + PermissionSet: []string{"iam:UpdateAssumeRolePolicy", "s3:GetObject"}, + Comments: "NEW_FINDING", + }, + }, + wantErr: false, + }, + { + name: "allRoles#7", + args: args{ + []Comments{}, + }, + initFindings: []reflectFinding{}, + flags: NewReflectFlags("us-east-1", nil, nil, true, true, false, "", 1), + mockedGetS3LogPrefixForCloudTrailResponse: aws.String("s3://lp-cl-111111111111-us-east-1/source=aws/account=111111111111/region=us-east-1/env=prod/aggregation=cloudtrail/service=cloudtrail/AWSLogs/111111111111/CloudTrail"), + mockedGetS3LogPrefixForCloudTrailError: nil, + mockedGetTableforMetadataResponse: nil, + mockedGetTableforMetadataError: nil, + mockedCreateTableFromMetadataResponse: aws.String("default.reflect_cloudtrail_gxev4"), + mockedCreateTableFromMetadataError: nil, + GetRolesFromTagsResponse: nil, + GetRolesFromTagsError: nil, + mockedUsageReportRunQueryResponse: athenaResultSetUsage, + mockedErrorReportRunQueryResponse: athenaResultSetError, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + GetNetIAMPermissionsForRolesResponse: map[string][]string{"arn:aws:iam::111111111111:role/AWS_111111111111_Read": {"iam:UpdateAssumeRolePolicy", "s3:GetObject"}}, + updatedFindings: []reflectFinding{ + { + AccountID: "111111111111", + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{ + {"iam.amazonaws.com/UpdateAssumeRolePolicy", 1}, + {"iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied", 1}, + }, + PermissionSet: []string{"iam:UpdateAssumeRolePolicy", "s3:GetObject"}, + Comments: "NEW_FINDING", + }, + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + report := &ReflectReport{ + Findings: tt.initFindings, + Flags: tt.flags, + } + logger.Level = 1 + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockAPI := mocks.NewMockAPIs(mockCtrl) + mockAPI.EXPECT().GetAccountID().Return("111111111111", nil) + mockAPI.EXPECT().GetS3LogPrefixForCloudTrail().Return(tt.mockedGetS3LogPrefixForCloudTrailResponse, tt.mockedGetS3LogPrefixForCloudTrailError) + mockAPI.EXPECT().GetTableforMetadata(gomock.Any()).Return(tt.mockedGetTableforMetadataResponse, tt.mockedGetTableforMetadataError).AnyTimes() + mockAPI.EXPECT().CreateTableFromMetadata(gomock.Any()).Return(tt.mockedCreateTableFromMetadataResponse, tt.mockedCreateTableFromMetadataError).AnyTimes() + mockAPI.EXPECT().GetRolesFromTags(gomock.Any()).Return(tt.GetRolesFromTagsResponse, tt.GetRolesFromTagsError).AnyTimes() + if tt.flags.usageReport { + mockAPI.EXPECT().RunQuery(gomock.Any(), gomock.Any()).Return(tt.mockedUsageReportRunQueryResponse, tt.mockedUsageReportRunQueryError).MaxTimes(1) + } + + if tt.flags.errorReport { + mockAPI.EXPECT().RunQuery(gomock.Any(), gomock.Any()).Return(tt.mockedErrorReportRunQueryResponse, tt.mockedErrorReportRunQueryError).MaxTimes(1) + } + mockAPI.EXPECT().GetNetIAMPermissionsForRoles(gomock.Any()).Return(tt.GetNetIAMPermissionsForRolesResponse).AnyTimes() + + if err := report.GetReport(mockAPI, tt.args.comments); (err != nil) != tt.wantErr { + t.Errorf("ReflectReport.GetReport() error = %v, wantErr %v", err, tt.wantErr) + } + if !reflect.DeepEqual(report.Findings, tt.updatedFindings) { + t.Errorf("ReflectReport.GetReport() = %#v, want %#v", report.Findings, tt.updatedFindings) + } + }) + } +} + +func TestReflectReport_populateFindings(t *testing.T) { + + type args struct { + tableName string + } + tests := []struct { + name string + args args + initFindings []reflectFinding + flags ReflectFlags + mockedUsageReportRunQueryResponse *athena.ResultSet + mockedErrorReportRunQueryResponse *athena.ResultSet + mockedUsageReportRunQueryError error + mockedErrorReportRunQueryError error + updatedFindings []reflectFinding + wantErr bool + }{ + { + name: "noData#1", + args: args{"default.reflect_cloudTrail_test1"}, + initFindings: []reflectFinding{}, + flags: ReflectFlags{ + usageReport: true, + errorReport: true, + }, + mockedUsageReportRunQueryResponse: &athena.ResultSet{}, + mockedErrorReportRunQueryResponse: &athena.ResultSet{}, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + updatedFindings: []reflectFinding{}, + wantErr: false, + }, + { + name: "runQueryError#2", + args: args{"default.reflect_cloudTrail_test1"}, + initFindings: []reflectFinding{}, + flags: ReflectFlags{ + usageReport: true, + errorReport: true, + }, + mockedUsageReportRunQueryResponse: &athena.ResultSet{}, + mockedErrorReportRunQueryResponse: &athena.ResultSet{}, + mockedUsageReportRunQueryError: errors.New("some error"), + mockedErrorReportRunQueryError: nil, + updatedFindings: []reflectFinding{}, + wantErr: true, + }, + { + name: "dataFromBothQueries#3", + args: args{"default.reflect_cloudTrail_test1"}, + initFindings: []reflectFinding{}, + flags: ReflectFlags{ + usageReport: true, + errorReport: true, + }, + mockedUsageReportRunQueryResponse: &athena.ResultSet{ + ResultSetMetadata: &athena.ResultSetMetadata{ColumnInfo: []*athena.ColumnInfo{ + { + Name: aws.String("arn"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventsource"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventname"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("count"), + Type: aws.String("varchar"), + }, + }}, + Rows: []*athena.Row{ + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn")}, + {VarCharValue: aws.String("eventsource")}, + {VarCharValue: aws.String("eventname")}, + {VarCharValue: aws.String("count")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass")}, + {VarCharValue: aws.String("sts.amazonaws.com")}, + {VarCharValue: aws.String("AssumeRole")}, + {VarCharValue: aws.String("15")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_Read")}, + {VarCharValue: aws.String("iam.amazonaws.com")}, + {VarCharValue: aws.String("UpdateAssumeRolePolicy")}, + {VarCharValue: aws.String("1")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/configuration-recorder-role")}, + {VarCharValue: aws.String("kms.amazonaws.com")}, + {VarCharValue: aws.String("DescribeKey")}, + {VarCharValue: aws.String("6")}, + }, + }, + }, + }, + mockedErrorReportRunQueryResponse: &athena.ResultSet{ + ResultSetMetadata: &athena.ResultSetMetadata{ColumnInfo: []*athena.ColumnInfo{ + { + Name: aws.String("arn"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventsource"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventname"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("errorcode"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("count"), + Type: aws.String("varchar"), + }, + }}, + Rows: []*athena.Row{ + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn")}, + {VarCharValue: aws.String("eventsource")}, + {VarCharValue: aws.String("eventname")}, + {VarCharValue: aws.String("errorcode")}, + {VarCharValue: aws.String("count")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass")}, + {VarCharValue: aws.String("sts.amazonaws.com")}, + {VarCharValue: aws.String("AssumeRole")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("15")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_Read")}, + {VarCharValue: aws.String("iam.amazonaws.com")}, + {VarCharValue: aws.String("UpdateAssumeRolePolicy")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("1")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/configuration-recorder-role")}, + {VarCharValue: aws.String("kms.amazonaws.com")}, + {VarCharValue: aws.String("DescribeKey")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("6")}, + }, + }, + }, + }, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + updatedFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass", + AccessDetails: []accessDetails{ + {"sts.amazonaws.com/AssumeRole", 15}, + {"sts.amazonaws.com/AssumeRole/AccessDenied", 15}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{ + {"iam.amazonaws.com/UpdateAssumeRolePolicy", 1}, + {"iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied", 1}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/configuration-recorder-role", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey", 6}, + {"kms.amazonaws.com/DescribeKey/AccessDenied", 6}, + }, + }, + }, + wantErr: false, + }, + { + name: "dataFromErrorQuery#4", + args: args{"default.reflect_cloudTrail_test1"}, + initFindings: []reflectFinding{}, + flags: ReflectFlags{ + usageReport: false, + errorReport: true, + }, + mockedUsageReportRunQueryResponse: &athena.ResultSet{}, + mockedErrorReportRunQueryResponse: &athena.ResultSet{ + ResultSetMetadata: &athena.ResultSetMetadata{ColumnInfo: []*athena.ColumnInfo{ + { + Name: aws.String("arn"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventsource"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("eventname"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("errorcode"), + Type: aws.String("varchar"), + }, + { + Name: aws.String("count"), + Type: aws.String("varchar"), + }, + }}, + Rows: []*athena.Row{ + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn")}, + {VarCharValue: aws.String("eventsource")}, + {VarCharValue: aws.String("eventname")}, + {VarCharValue: aws.String("errorcode")}, + {VarCharValue: aws.String("count")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass")}, + {VarCharValue: aws.String("sts.amazonaws.com")}, + {VarCharValue: aws.String("AssumeRole")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("15")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/AWS_111111111111_Read")}, + {VarCharValue: aws.String("iam.amazonaws.com")}, + {VarCharValue: aws.String("UpdateAssumeRolePolicy")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("1")}, + }, + }, + { + Data: []*athena.Datum{ + {VarCharValue: aws.String("arn:aws:iam::111111111111:role/configuration-recorder-role")}, + {VarCharValue: aws.String("kms.amazonaws.com")}, + {VarCharValue: aws.String("DescribeKey")}, + {VarCharValue: aws.String("AccessDenied")}, + {VarCharValue: aws.String("6")}, + }, + }, + }, + }, + mockedUsageReportRunQueryError: nil, + mockedErrorReportRunQueryError: nil, + updatedFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass", + AccessDetails: []accessDetails{ + {"sts.amazonaws.com/AssumeRole/AccessDenied", 15}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/AWS_111111111111_Read", + AccessDetails: []accessDetails{ + {"iam.amazonaws.com/UpdateAssumeRolePolicy/AccessDenied", 1}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/configuration-recorder-role", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 6}, + }, + }, + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + report := &ReflectReport{ + Findings: tt.initFindings, + Flags: tt.flags, + } + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + mockAPI := mocks.NewMockAPIs(mockCtrl) + if tt.flags.usageReport { + mockAPI.EXPECT().RunQuery(gomock.Any(), gomock.Any()).Return(tt.mockedUsageReportRunQueryResponse, tt.mockedUsageReportRunQueryError) + } + + if tt.flags.errorReport { + mockAPI.EXPECT().RunQuery(gomock.Any(), gomock.Any()).Return(tt.mockedErrorReportRunQueryResponse, tt.mockedErrorReportRunQueryError).AnyTimes() + } + + findings, err := populateFindings(mockAPI, tt.args.tableName, report.Flags) + if (err != nil) != tt.wantErr { + t.Errorf("ReflectReport.populateFindings() error = %v, wantErr %v", err, tt.wantErr) + } + + if !reflect.DeepEqual(findings, tt.updatedFindings) { + t.Errorf("ReflectReport.populateFindings() = %v, want %v", findings, tt.updatedFindings) + } + }) + } +} + +func TestReflectReport_updateFinding(t *testing.T) { + type args struct { + identity string + eventD accessDetails + } + tests := []struct { + name string + args args + providedRoles []string + initFindings []reflectFinding + updatedFindings []reflectFinding + }{ + { + name: "simpleAdd#1", + args: args{ + identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + eventD: accessDetails{"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + }, + initFindings: []reflectFinding{}, + updatedFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + }, + }, + }, + }, + { + name: "simpleUpdate#2", + args: args{ + identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + eventD: accessDetails{"kms.amazonaws.com/CreateKey", 5}, + }, + initFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + }, + }, + }, + updatedFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + }, + }, + { + name: "addNewIdentity#3", + args: args{ + identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + eventD: accessDetails{"kms.amazonaws.com/Decrypt", 7}, + }, + initFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + }, + updatedFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/Decrypt", 7}, + }, + }, + }, + }, + { + name: "updateCount#4", + args: args{ + identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + eventD: accessDetails{"kms.amazonaws.com/Decrypt", 13}, + }, + initFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/Decrypt", 7}, + }, + }, + }, + updatedFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/Decrypt", 20}, + }, + }, + }, + }, + { + name: "filterRole#5", + args: args{ + identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-stage", + eventD: accessDetails{"kms.amazonaws.com/Decrypt", 31}, + }, + providedRoles: []string{"arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev"}, + initFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/Decrypt", 7}, + }, + }, + }, + updatedFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/Decrypt", 7}, + }, + }, + }, + }, + { + name: "filterRole#6", + args: args{ + identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-stage", + eventD: accessDetails{"kms.amazonaws.com/Decrypt", 31}, + }, + providedRoles: []string{"arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", "arn:aws:iam::111111111111:role/web-gateway-greencherry-stage"}, + initFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/Decrypt", 7}, + }, + }, + }, + updatedFindings: []reflectFinding{ + { + Identity: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + {"kms.amazonaws.com/CreateKey", 5}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/Decrypt", 7}, + }, + }, + { + Identity: "arn:aws:iam::111111111111:role/web-gateway-greencherry-stage", + AccessDetails: []accessDetails{ + {"kms.amazonaws.com/Decrypt", 31}, + }, + }, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + report := &ReflectReport{} + report.Flags.roles = tt.providedRoles + updateFinding(report.Flags, &tt.initFindings, tt.args.identity, tt.args.eventD) + if !reflect.DeepEqual(tt.initFindings, tt.updatedFindings) { + t.Errorf("updateFinding() = %v, want %v", tt.initFindings, tt.updatedFindings) + } + }) + } +} + +func Test_constructFinding(t *testing.T) { + type args struct { + dataSlice []string + keys []string + } + tests := []struct { + name string + args args + want string + want1 accessDetails + }{ + { + name: "withErrorCode#1", + args: args{ + dataSlice: []string{"arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", "kms.amazonaws.com", "DescribeKey", "AccessDenied", "18"}, + keys: []string{"arn", "eventsource", "eventname", "errorcode", "count"}, + }, + want: "arn:aws:iam::111111111111:role/AWSServiceRoleForAccessAnalyzer", + want1: accessDetails{"kms.amazonaws.com/DescribeKey/AccessDenied", 18}, + }, + { + name: "withOutErrorCode#2", + args: args{ + dataSlice: []string{"arn:aws:iam::111111111111:role/AWSServiceRoleForAmazonInspector", "ec2.amazonaws.com", "DescribeVpnGateways", "1"}, + keys: []string{"arn", "eventsource", "eventname", "count"}, + }, + want: "arn:aws:iam::111111111111:role/AWSServiceRoleForAmazonInspector", + want1: accessDetails{"ec2.amazonaws.com/DescribeVpnGateways", 1}, + }, + { + name: "withIdentity#3", + args: args{ + dataSlice: []string{"arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", "arn:aws:sts::111111111111:assumed-role/web-gateway-greencherry-dev/aws-sdk-java-1606285491012", "kms.amazonaws.com", "Decrypt", "3"}, + keys: []string{"arn", "identity_arn", "eventsource", "eventname", "count"}, + }, + want: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev@aws-sdk-java-1606285491012", + want1: accessDetails{"kms.amazonaws.com/Decrypt", 3}, + }, + { + name: "withIdentityAndErrorCode#4", + args: args{ + dataSlice: []string{"arn:aws:iam::111111111111:role/web-gateway-greencherry-dev", "arn:aws:sts::111111111111:assumed-role/web-gateway-greencherry-dev/aws-sdk-java-1606285491012", "kms.amazonaws.com", "DescribeKey", "AccessDenied", "19"}, + keys: []string{"arn", "identity_arn", "eventsource", "eventname", "errorcode", "count"}, + }, + want: "arn:aws:iam::111111111111:role/web-gateway-greencherry-dev@aws-sdk-java-1606285491012", + want1: accessDetails{"kms.amazonaws.com/DescribeKey/AccessDenied", 19}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, got1 := constructFinding(tt.args.dataSlice, tt.args.keys) + if got != tt.want { + t.Errorf("constructFinding() got = %v, want %v", got, tt.want) + } + if !reflect.DeepEqual(got1, tt.want1) { + t.Errorf("constructFinding() got1 = %v, want %v", got1, tt.want1) + } + }) + } +} + +func Test_createQueryFromFlags(t *testing.T) { + type args struct { + flags ReflectFlags + tableName string + queryType string + } + tests := []struct { + name string + args args + want string + }{ + { + name: "queryUsage#1", + args: args{ + flags: ReflectFlags{ + region: "us-east-1", + roles: []string{"arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass"}, + roleTags: map[string]string{}, + usageReport: true, + errorReport: true, + includeUserIdentity: true, + absoluteTime: "10/25/2020-10/31/2020", + relativeTime: 0, + }, + tableName: "default.reflect_cloudtrail_cf4zi", + queryType: queryForUsage, + }, + want: ` +SELECT useridentity.sessioncontext.sessionissuer.arn,useridentity.arn AS identity_arn,eventsource,eventname,count(eventname) AS count +FROM default.reflect_cloudtrail_cf4zi +WHERE region='us-east-1' + AND year IN ('2020') + AND month IN ('10') + AND day IN ('25','26','27','28','29','30','31') + AND eventtime >= '2020-10-25T00:00:00Z' + AND eventtime <= '2020-10-31T23:59:59Z' + AND useridentity.sessioncontext.sessionissuer.arn LIKE 'arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass' +GROUP BY useridentity.arn,eventsource,eventname,useridentity.sessioncontext.sessionissuer.arn +ORDER BY useridentity.arn,count DESC +`, + }, + { + name: "queryError#2", + args: args{ + flags: ReflectFlags{ + region: "us-east-2", + roles: []string{"arn:aws:iam::111111111111:role/AWS_111111111111_BreakDoor"}, + roleTags: map[string]string{}, + usageReport: true, + errorReport: true, + includeUserIdentity: false, + absoluteTime: "09/03/2020-11/12/2020", + relativeTime: 0, + }, + tableName: "default.reflect_cloudtrail_cf4zi", + queryType: queryForErrors, + }, + want: ` +SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode,count(useridentity.sessioncontext.sessionissuer.arn) AS count +FROM default.reflect_cloudtrail_cf4zi +WHERE region='us-east-2' + AND year IN ('2020') + AND month IN ('09','10','11') + AND day IN ('01','02','03','04','05','06','07','08','09','10','11','12','13','14','15','16','17','18','19','20','21','22','23','24','25','26','27','28','29','30','31') + AND eventtime >= '2020-09-03T00:00:00Z' + AND eventtime <= '2020-11-12T23:59:59Z' + AND useridentity.arn != '' + AND useridentity.sessioncontext.sessionissuer.arn LIKE 'arn:aws:iam::111111111111:role/AWS_111111111111_BreakDoor' + AND (errorcode LIKE '%UnauthorizedOperation' OR errorcode LIKE 'AccessDenied%') +GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode +ORDER BY useridentity.arn,count DESC +`, + }, + { + name: "queryError#3", + args: args{ + flags: ReflectFlags{ + region: "us-east-1", + roles: []string{"arn:aws:iam::111111111111:role/AWS_111111111111_BreakDoor", "arn:aws:iam::111111111111:role/AWS_111111111111_BreakChair"}, + roleTags: map[string]string{}, + usageReport: true, + errorReport: true, + absoluteTime: "03/03/2020-09/02/2020", + relativeTime: 0, + }, + tableName: "default.reflect_cloudtrail_cf4zi", + queryType: queryForErrors, + }, + want: ` +SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode,count(useridentity.sessioncontext.sessionissuer.arn) AS count +FROM default.reflect_cloudtrail_cf4zi +WHERE region='us-east-1' + AND year IN ('2020') + AND month IN ('03','04','05','06','07','08','09') + AND day IN ('01','02','03','04','05','06','07','08','09','10','11','12','13','14','15','16','17','18','19','20','21','22','23','24','25','26','27','28','29','30','31') + AND eventtime >= '2020-03-03T00:00:00Z' + AND eventtime <= '2020-09-02T23:59:59Z' + AND useridentity.arn != '' + AND (errorcode LIKE '%UnauthorizedOperation' OR errorcode LIKE 'AccessDenied%') +GROUP BY useridentity.arn,useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,errorcode +ORDER BY useridentity.arn,count DESC +`, + }, + { + name: "queryUsage#4", + args: args{ + flags: ReflectFlags{ + region: "us-east-2", + roles: []string{"arn:aws:iam::111111111111:role/AWS_111111111111_BreakGlass", "arn:aws:iam::111111111111:role/AWS_111111111111_BreakFan", "arn:aws:iam::111111111111:role/AWS_111111111111_BreakTV"}, + roleTags: map[string]string{}, + usageReport: true, + errorReport: true, + absoluteTime: "10/25/2020-10/25/2020", + relativeTime: 0, + }, + tableName: "default.reflect_cloudtrail_cf4zi", + queryType: queryForUsage, + }, + want: ` +SELECT useridentity.sessioncontext.sessionissuer.arn,eventsource,eventname,count(eventname) AS count +FROM default.reflect_cloudtrail_cf4zi +WHERE region='us-east-2' + AND year IN ('2020') + AND month IN ('10') + AND day IN ('25') + AND eventtime >= '2020-10-25T00:00:00Z' + AND eventtime <= '2020-10-25T23:59:59Z' +GROUP BY useridentity.arn,eventsource,eventname,useridentity.sessioncontext.sessionissuer.arn +ORDER BY useridentity.arn,count DESC +`, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := createQueryFromFlags(tt.args.flags, tt.args.tableName, tt.args.queryType); got != tt.want { + t.Errorf("createQueryFromFlags() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_getAbsoluteTime(t *testing.T) { + type args struct { + timeRelative int + now time.Time + } + tests := []struct { + name string + args args + want string + }{ + { + name: "#1", + args: args{ + timeRelative: 10, + now: time.Date(2020, time.November, 10, 23, 0, 0, 0, time.UTC), + }, + want: "10/31/2020-11/10/2020", + }, + { + name: "#2", + args: args{ + timeRelative: 0, + now: time.Date(2020, time.November, 10, 23, 0, 0, 0, time.UTC), + }, + want: "11/10/2020-11/10/2020", + }, + { + name: "#3", + args: args{ + timeRelative: 90, + now: time.Date(2020, time.November, 10, 23, 0, 0, 0, time.UTC), + }, + want: "08/12/2020-11/10/2020", + }, + { + name: "#4", + args: args{ + timeRelative: 370, + now: time.Date(2020, time.November, 10, 23, 0, 0, 0, time.UTC), + }, + want: "11/06/2019-11/10/2020", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := getAbsoluteTime(tt.args.timeRelative, tt.args.now); got != tt.want { + t.Errorf("getAbsoluteTime() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_ConstructPartitionDataFromTime(t *testing.T) { + testCases := []struct { + name string + timeAbsolute string + expectedOutput timeRange + }{ + { + name: "absoluteOnly#1", + timeAbsolute: "10/01/2020-10/01/2020", + expectedOutput: timeRange{ + Months: []int{10}, + Days: []int{1}, + Years: []int{2020}, + EventTimeRange: []string{"2020-10-01T00:00:00Z", "2020-10-01T23:59:59Z"}, + }, + }, + { + name: "absoluteOnly#2", + timeAbsolute: "10/02/2020-10/04/2020", + expectedOutput: timeRange{ + Months: []int{10}, + Days: []int{2, 3, 4}, + Years: []int{2020}, + EventTimeRange: []string{"2020-10-02T00:00:00Z", "2020-10-04T23:59:59Z"}, + }, + }, + { + name: "absoluteOnly#3", + timeAbsolute: "10/09/2020-10/17/2020", + expectedOutput: timeRange{ + Months: []int{10}, + Days: []int{9, 10, 11, 12, 13, 14, 15, 16, 17}, + Years: []int{2020}, + EventTimeRange: []string{"2020-10-09T00:00:00Z", "2020-10-17T23:59:59Z"}, + }, + }, + { + name: "absoluteOnly#4", + timeAbsolute: "10/01/2020-10/30/2020", + expectedOutput: timeRange{ + Months: []int{10}, + Days: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30}, + Years: []int{2020}, + EventTimeRange: []string{"2020-10-01T00:00:00Z", "2020-10-30T23:59:59Z"}, + }, + }, + { + name: "absoluteOnly#5", + timeAbsolute: "10/01/2020-11/30/2020", + expectedOutput: timeRange{ + Months: []int{10, 11}, + Days: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, + Years: []int{2020}, + EventTimeRange: []string{"2020-10-01T00:00:00Z", "2020-11-30T23:59:59Z"}, + }, + }, + { + name: "absoluteOnly#6", + timeAbsolute: "10/06/2020-12/04/2020", + expectedOutput: timeRange{ + Months: []int{10, 11, 12}, + Days: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, + Years: []int{2020}, + EventTimeRange: []string{"2020-10-06T00:00:00Z", "2020-12-04T23:59:59Z"}, + }, + }, + { + name: "absolute#7", + timeAbsolute: "10/01/2020-03/30/2021", + expectedOutput: timeRange{ + Months: []int{1, 2, 3, 10, 11, 12}, + Days: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, + Years: []int{2020, 2021}, + EventTimeRange: []string{"2020-10-01T00:00:00Z", "2021-03-30T23:59:59Z"}, + }, + }, + { + name: "absolute#8", + timeAbsolute: "02/28/2019-09/14/2021", + expectedOutput: timeRange{ + Months: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, + Days: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, + Years: []int{2019, 2020, 2021}, + EventTimeRange: []string{"2019-02-28T00:00:00Z", "2021-09-14T23:59:59Z"}, + }, + }, + { + name: "absolute#9", + timeAbsolute: "10/17/2019-04/12/2020", + expectedOutput: timeRange{ + Months: []int{1, 2, 3, 4, 10, 11, 12}, + Days: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, + Years: []int{2019, 2020}, + EventTimeRange: []string{"2019-10-17T00:00:00Z", "2020-04-12T23:59:59Z"}, + }, + }, + { + name: "absolute#10", + timeAbsolute: "10/04/2020-11/04/2020", + expectedOutput: timeRange{ + Months: []int{10, 11}, + Days: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, + Years: []int{2020}, + EventTimeRange: []string{"2020-10-04T00:00:00Z", "2020-11-04T23:59:59Z"}, + }, + }, + } + + for _, tt := range testCases { + t.Run(tt.name, func(t *testing.T) { + if got := constructPartitionDataFromTime(tt.timeAbsolute); !reflect.DeepEqual(got, tt.expectedOutput) { + t.Errorf("constructPartitionDataFromTime() = %v, want %v", got, tt.expectedOutput) + } + }) + } +} diff --git a/pkg/cloudig/trustedadvisor.go b/pkg/cloudig/trustedadvisor.go new file mode 100644 index 0000000..81620ad --- /dev/null +++ b/pkg/cloudig/trustedadvisor.go @@ -0,0 +1,82 @@ +package cloudig + +import ( + "strings" + "time" + + awslocal "github.com/Optum/cloudig/pkg/aws" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/support" + "github.com/kris-nova/logger" +) + +// TrustedAdvisorReport is struct that contains an array of Trusted Advisor findings +type TrustedAdvisorReport struct { + Findings []trustedAdvisorFinding `json:"findings"` + jsonOutputHelper +} + +type trustedAdvisorFinding struct { + AccountID string `json:"accountId"` + Category string `json:"category"` + Name string `json:"name"` + Description string `json:"description"` + Status string `json:"status"` + ResourcesSummary support.TrustedAdvisorResourcesSummary `json:"resourcesSummary"` // map[string]int64 + FlaggedResources []string `json:"flaggedResources"` + Comments string `json:"comments"` +} + +// GetReport retrives the trusted advisor report for a given account, +func (report *TrustedAdvisorReport) GetReport(client awslocal.APIs, comments []Comments) error { + start := time.Now() + finding := trustedAdvisorFinding{} + + // Get accountID from roleARN + accountID, err := client.GetAccountID() + if err != nil { + return err + } + logger.Info("working on TrustedAdvisorReport for account: %s", accountID) + logger.Info("finding failing Trusted Advisor checks for account: %s", accountID) + results, err := client.GetFailingTrustedAdvisorCheckResults() + if err != nil { + return err + } + + report.Findings = processTrustedAdvisorResults(results, accountID, comments) + logger.Success("getting AWS TrustedAdvisorReport for account %s took %s", finding.AccountID, time.Since(start)) + return nil +} + +func processTrustedAdvisorResults(results map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult, accountID string, comments []Comments) []trustedAdvisorFinding { + findings := make([]trustedAdvisorFinding, 0) + for check, result := range results { + finding := trustedAdvisorFinding{ + AccountID: accountID, + Category: strings.ToUpper(aws.StringValue(check.Category)), + Name: aws.StringValue(check.Name), + Description: strings.TrimSpace(strings.Split(aws.StringValue(check.Description), "
+ Estimated monthly savings are calculated by using the current usage rate for On-Demand Instances and the estimated number of days the instance might be underutilized. Actual savings will vary if you are using Reserved Instances or Spot Instances, or if the instance is not running for a full day. To get daily utilization data, download the report for this check. +
+
+ Alert Criteria
+ Yellow: An instance had 10% or less daily average CPU utilization and 5 MB or less network I/O on at least 4 of the previous 14 days.
+
+ Recommended Action
+ Consider stopping or terminating instances that have low utilization, or scale the number of instances by using Auto Scaling. For more information, see Stop and Start Your Instance, Terminate Your Instance, and What is Auto Scaling?
+
+ Additional Resources
+ Monitoring Amazon EC2
+ Instance Metadata and User Data
+ Amazon CloudWatch Developer Guide
+ Auto Scaling Developer Guide`), + Metadata: aws.StringSlice([]string{"Status", "Region", "instance-id", "Name"}), + Name: aws.String("Low Utilization Amazon EC2 Instances"), + }: { + Status: aws.String("warning"), + FlaggedResources: []*support.TrustedAdvisorResourceDetail{ + { + IsSuppressed: aws.Bool(false), + Metadata: aws.StringSlice([]string{ + "Yellow", + "us-east-1", + "i-0123456789abcdefg", + "k8s.example.com", + "m5.2xlarge", + "$276.48", + "1.8% 3.34MB", + "1.7% 3.29MB", + "1.6% 3.29MB", + "1.6% 3.32MB", + "1.6% 3.28MB", + "1.7% 3.41MB", + "1.6% 3.43MB", + "1.6% 3.47MB", + "1.9% 3.34MB", + "1.6% 3.29MB", + "1.6% 3.40MB", + "1.7% 3.48MB", + "1.7% 3.51MB", + "1.7% 3.43MB", + "1.7%", + "3.37MB", + "14 days"}, + ), + Region: aws.String("us-east-1"), + ResourceId: aws.String("QtCJL9NshMFH8AHUBLdX_fvrnAOPSTpR-hzxk0YU4oI"), + Status: aws.String("warning"), + }, + { + IsSuppressed: aws.Bool(false), + Metadata: aws.StringSlice([]string{ + "Yellow", + "us-east-1", + "i-abcdefg0123456789", + "k8s.example.com", + "m5.2xlarge", + "$276.48", + "1.0% 2.61MB", + "1.1% 2.57MB", + "1.0% 2.56MB", + "1.0% 2.60MB", + "1.0% 2.55MB", + "1.0% 2.69MB", + "1.0% 2.70MB", + "1.0% 2.73MB", + "1.1% 2.63MB", + "1.0% 2.55MB", + "1.0% 2.66MB", + "1.0% 2.75MB", + "1.0% 2.78MB", + "1.0% 2.70MB", + "1.0%", + "2.65MB", + "14 days"}, + ), + Region: aws.String("us-east-1"), + ResourceId: aws.String("M1nMGLq-DqEbS0jbaObJ1IXucGlQ_bcOOBBLQSVcCjU"), + Status: aws.String("warning"), + }, + // This is just to test filtering out resources that have "Green" in their metadata + { + Metadata: aws.StringSlice([]string{ + "Green", + }, + ), + }, + }, + ResourcesSummary: &support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(10), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(12), + ResourcesSuppressed: aws.Int64(0), + }, + }, + { + Category: aws.String("security"), + Description: aws.String(`Checks for your use of AWS Identity and Access Management (IAM). You can use IAM to create users, groups, and roles in AWS, and you can use permissions to control access to AWS resources. +
+
+ Alert Criteria
+ Yellow: No IAM users have been created for this account. +
+
+ Recommended Action
+ Create one or more IAM users and groups in your account. You can then create additional users whose permissions are limited to perform specific tasks in your AWS environment. For more information, see Getting Started. +

+ Additional Resources
+ What Is IAM?`), + Name: aws.String("IAM Use"), + }: { + Status: aws.String("warning"), + FlaggedResources: []*support.TrustedAdvisorResourceDetail{{ + IsSuppressed: aws.Bool(false), + ResourceId: aws.String("47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU"), + Status: aws.String("warning"), + }, + }, + ResourcesSummary: &support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(1), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(1), + ResourcesSuppressed: aws.Int64(0), + }, + }, + }, + expectedFindings: []trustedAdvisorFinding{ + { + AccountID: "111111111111", + Category: "COST_OPTIMIZING", + Name: "Low Utilization Amazon EC2 Instances", + Description: `Checks the Amazon Elastic Compute Cloud (Amazon EC2) instances that were running at any time during the last 14 days and alerts you if the daily CPU utilization was 10% or less and network I/O was 5 MB or less on 4 or more days. Running instances generate hourly usage charges. Although some scenarios can result in low utilization by design, you can often lower your costs by managing the number and size of your instances.`, + Status: "warning", + ResourcesSummary: support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(10), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(12), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []string{"us-east-1/i-0123456789abcdefg", "us-east-1/i-abcdefg0123456789"}, + Comments: "NEW_FINDING", + }, { + AccountID: "111111111111", + Category: "SECURITY", + Name: "IAM Use", + Description: "Checks for your use of AWS Identity and Access Management (IAM). You can use IAM to create users, groups, and roles in AWS, and you can use permissions to control access to AWS resources.", + Status: "warning", + ResourcesSummary: support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(1), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(1), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []string{"NA"}, + Comments: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM", + }, + }, + }, + { + name: "Return error when getting Account ID", + accountID: "", + mockGetFailingTrustedAdvisorCheckResultsError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + { + name: "Return error when running GetFailingTrustedAdvisorCheckResult", + accountID: "12345", + mockGetFailingTrustedAdvisorCheckResultsError: errors.New("Some API error"), + expectedError: errors.New("Some API error"), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + mockAPIs := mocks.NewMockAPIs(mockCtrl) + mockAPIs.EXPECT().GetAccountID().Return(tc.accountID, tc.mockGetAccountIDError).MaxTimes(1) + mockAPIs.EXPECT().GetFailingTrustedAdvisorCheckResults().Return(tc.mockGetFailingTrustedAdvisorCheckResultsResponse, tc.mockGetFailingTrustedAdvisorCheckResultsError).MaxTimes(1) + + comments := parseCommentsFile("../../test/data/comments.yaml") + report := &TrustedAdvisorReport{} + err := report.GetReport(mockAPIs, comments) + + assert.ElementsMatch(t, tc.expectedFindings, report.Findings) + assert.Equal(t, tc.expectedError, err) + }) + } +} + +func TestProcessTrustedAdvisorResults(t *testing.T) { + testCases := []struct { + name string + results map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult + account string + expectedOutput []trustedAdvisorFinding + }{ + { + name: "Return expected results", + results: map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult{ + { + Category: aws.String("cost_optimizing"), + Description: aws.String(`Checks the Amazon Elastic Compute Cloud (Amazon EC2) instances that were running at any time during the last 14 days and alerts you if the daily CPU utilization was 10% or less and network I/O was 5 MB or less on 4 or more days. Running instances generate hourly usage charges. Although some scenarios can result in low utilization by design, you can often lower your costs by managing the number and size of your instances. +

+ Estimated monthly savings are calculated by using the current usage rate for On-Demand Instances and the estimated number of days the instance might be underutilized. Actual savings will vary if you are using Reserved Instances or Spot Instances, or if the instance is not running for a full day. To get daily utilization data, download the report for this check. +
+
+ Alert Criteria
+ Yellow: An instance had 10% or less daily average CPU utilization and 5 MB or less network I/O on at least 4 of the previous 14 days.
+
+ Recommended Action
+ Consider stopping or terminating instances that have low utilization, or scale the number of instances by using Auto Scaling. For more information, see Stop and Start Your Instance, Terminate Your Instance, and What is Auto Scaling?
+
+ Additional Resources
+ Monitoring Amazon EC2
+ Instance Metadata and User Data
+ Amazon CloudWatch Developer Guide
+ Auto Scaling Developer Guide`), + Metadata: aws.StringSlice([]string{"Status", "Region", "instance-id", "Name"}), + Name: aws.String("Low Utilization Amazon EC2 Instances"), + }: { + Status: aws.String("warning"), + FlaggedResources: []*support.TrustedAdvisorResourceDetail{ + { + IsSuppressed: aws.Bool(false), + Metadata: aws.StringSlice([]string{ + "Yellow", + "us-east-1", + "i-0123456789abcdefg", + "k8s.example.com", + "m5.2xlarge", + "$276.48", + "1.8% 3.34MB", + "1.7% 3.29MB", + "1.6% 3.29MB", + "1.6% 3.32MB", + "1.6% 3.28MB", + "1.7% 3.41MB", + "1.6% 3.43MB", + "1.6% 3.47MB", + "1.9% 3.34MB", + "1.6% 3.29MB", + "1.6% 3.40MB", + "1.7% 3.48MB", + "1.7% 3.51MB", + "1.7% 3.43MB", + "1.7%", + "3.37MB", + "14 days"}, + ), + Region: aws.String("us-east-1"), + ResourceId: aws.String("QtCJL9NshMFH8AHUBLdX_fvrnAOPSTpR-hzxk0YU4oI"), + Status: aws.String("warning"), + }, + { + IsSuppressed: aws.Bool(false), + Metadata: aws.StringSlice([]string{ + "Yellow", + "us-east-1", + "i-abcdefg0123456789", + "k8s.example.com", + "m5.2xlarge", + "$276.48", + "1.0% 2.61MB", + "1.1% 2.57MB", + "1.0% 2.56MB", + "1.0% 2.60MB", + "1.0% 2.55MB", + "1.0% 2.69MB", + "1.0% 2.70MB", + "1.0% 2.73MB", + "1.1% 2.63MB", + "1.0% 2.55MB", + "1.0% 2.66MB", + "1.0% 2.75MB", + "1.0% 2.78MB", + "1.0% 2.70MB", + "1.0%", + "2.65MB", + "14 days"}, + ), + Region: aws.String("us-east-1"), + ResourceId: aws.String("M1nMGLq-DqEbS0jbaObJ1IXucGlQ_bcOOBBLQSVcCjU"), + Status: aws.String("warning"), + }, + // This is just to test filtering out resources that have "Green" in their metadata + { + Metadata: aws.StringSlice([]string{ + "Green", + }, + ), + }, + }, + ResourcesSummary: &support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(10), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(12), + ResourcesSuppressed: aws.Int64(0), + }, + }, + { + Category: aws.String("security"), + Description: aws.String(`Checks for your use of AWS Identity and Access Management (IAM). You can use IAM to create users, groups, and roles in AWS, and you can use permissions to control access to AWS resources. +
+
+ Alert Criteria
+ Yellow: No IAM users have been created for this account. +
+
+ Recommended Action
+ Create one or more IAM users and groups in your account. You can then create additional users whose permissions are limited to perform specific tasks in your AWS environment. For more information, see Getting Started. +

+ Additional Resources
+ What Is IAM?`), + Name: aws.String("IAM Use"), + }: { + Status: aws.String("warning"), + FlaggedResources: []*support.TrustedAdvisorResourceDetail{{ + IsSuppressed: aws.Bool(false), + ResourceId: aws.String("47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU"), + Status: aws.String("warning"), + }, + }, + ResourcesSummary: &support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(1), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(1), + ResourcesSuppressed: aws.Int64(0), + }, + }, + }, + account: "111111111111", + expectedOutput: []trustedAdvisorFinding{ + { + AccountID: "111111111111", + Category: "COST_OPTIMIZING", + Name: "Low Utilization Amazon EC2 Instances", + Description: `Checks the Amazon Elastic Compute Cloud (Amazon EC2) instances that were running at any time during the last 14 days and alerts you if the daily CPU utilization was 10% or less and network I/O was 5 MB or less on 4 or more days. Running instances generate hourly usage charges. Although some scenarios can result in low utilization by design, you can often lower your costs by managing the number and size of your instances.`, + Status: "warning", + ResourcesSummary: support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(10), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(12), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []string{"us-east-1/i-0123456789abcdefg", "us-east-1/i-abcdefg0123456789"}, + Comments: "NEW_FINDING", + }, { + AccountID: "111111111111", + Category: "SECURITY", + Name: "IAM Use", + Description: "Checks for your use of AWS Identity and Access Management (IAM). You can use IAM to create users, groups, and roles in AWS, and you can use permissions to control access to AWS resources.", + Status: "warning", + ResourcesSummary: support.TrustedAdvisorResourcesSummary{ + ResourcesFlagged: aws.Int64(1), + ResourcesIgnored: aws.Int64(0), + ResourcesProcessed: aws.Int64(1), + ResourcesSuppressed: aws.Int64(0), + }, + FlaggedResources: []string{"NA"}, + Comments: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM", + }, + }, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Use comments file for testing + comments := parseCommentsFile("../../test/data/comments.yaml") + output := processTrustedAdvisorResults(tc.results, tc.account, comments) + assert.ElementsMatch(t, tc.expectedOutput, output) + }) + } +} diff --git a/pkg/cloudig/utils.go b/pkg/cloudig/utils.go new file mode 100644 index 0000000..c3def3e --- /dev/null +++ b/pkg/cloudig/utils.go @@ -0,0 +1,31 @@ +package cloudig + +// Contains tells whether slice of strings 'ss' contains string 's'. +func Contains(ss []string, s string) bool { + for _, n := range ss { + if s == n { + return true + } + } + return false +} + +// find the min of a & b +func min(a, b int) int { + if a < b { + return a + } + return b +} + +// ContainsKey returns value if key present in slice of map[string]string +func ContainsKey(sm []map[string]string, key string) string { + for _, sm := range sm { + for k, v := range sm { + if k == key { + return v + } + } + } + return "NEW_FINDING" +} diff --git a/pkg/cloudig/utils_test.go b/pkg/cloudig/utils_test.go new file mode 100644 index 0000000..7867158 --- /dev/null +++ b/pkg/cloudig/utils_test.go @@ -0,0 +1,97 @@ +package cloudig + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestContains(t *testing.T) { + type args struct { + a []string + x string + } + tests := []struct { + name string + args args + want bool + }{ + { + name: "#1", + args: args{a: []string{"a", "b", "c"}, x: "c"}, + want: true, + }, + { + name: "#2", + args: args{a: []string{"a", "b", "c"}, x: "d"}, + want: false, + }, + { + name: "#3", + args: args{a: []string{}, x: "d"}, + want: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := Contains(tt.args.a, tt.args.x); got != tt.want { + t.Errorf("Contains() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestMin(t *testing.T) { + output := min(1, 2) + assert.Equal(t, 1, output) + output = min(1, 1) + assert.Equal(t, 1, output) + output = min(1, 0) + assert.Equal(t, 0, output) +} + +func TestContainsKey(t *testing.T) { + type args struct { + sm []map[string]string + key string + } + tests := []struct { + name string + args args + want string + }{ + { + "#1", + args{[]map[string]string{ + {"k1": "v1", "k2": "v2", "k3": "v3"}, + {"kk1": "vv1", "kk2": "vv2"}, + {"a1": "v1"}, + }, + "kk2"}, + "vv2", + }, + { + "#2", + args{[]map[string]string{ + {"k1": "v1", "k2": "v2", "k3": "v3"}, + {"kk1": "vv1", "kk2": "vv2"}, + {"a1": "v1"}, + }, + "kk3"}, + "NEW_FINDING", + }, + { + "#3", + args{[]map[string]string{}, + "a1"}, + "NEW_FINDING", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := ContainsKey(tt.args.sm, tt.args.key); got != tt.want { + t.Errorf("ContainsKey() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/mocks/README.md b/pkg/mocks/README.md new file mode 100644 index 0000000..91d0b58 --- /dev/null +++ b/pkg/mocks/README.md @@ -0,0 +1,9 @@ +# Mocks + +These mocks were generated using [mockgen](https://github.com/golang/mock) + +Generating mocks: + +``` bash +make mocks +``` diff --git a/pkg/mocks/mock_athena.go b/pkg/mocks/mock_athena.go new file mode 100644 index 0000000..ab99744 --- /dev/null +++ b/pkg/mocks/mock_athena.go @@ -0,0 +1,1700 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/athena/athenaiface (interfaces: AthenaAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + athena "github.com/aws/aws-sdk-go/service/athena" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockAthenaAPI is a mock of AthenaAPI interface +type MockAthenaAPI struct { + ctrl *gomock.Controller + recorder *MockAthenaAPIMockRecorder +} + +// MockAthenaAPIMockRecorder is the mock recorder for MockAthenaAPI +type MockAthenaAPIMockRecorder struct { + mock *MockAthenaAPI +} + +// NewMockAthenaAPI creates a new mock instance +func NewMockAthenaAPI(ctrl *gomock.Controller) *MockAthenaAPI { + mock := &MockAthenaAPI{ctrl: ctrl} + mock.recorder = &MockAthenaAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockAthenaAPI) EXPECT() *MockAthenaAPIMockRecorder { + return m.recorder +} + +// BatchGetNamedQuery mocks base method +func (m *MockAthenaAPI) BatchGetNamedQuery(arg0 *athena.BatchGetNamedQueryInput) (*athena.BatchGetNamedQueryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetNamedQuery", arg0) + ret0, _ := ret[0].(*athena.BatchGetNamedQueryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetNamedQuery indicates an expected call of BatchGetNamedQuery +func (mr *MockAthenaAPIMockRecorder) BatchGetNamedQuery(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetNamedQuery", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetNamedQuery), arg0) +} + +// BatchGetNamedQueryRequest mocks base method +func (m *MockAthenaAPI) BatchGetNamedQueryRequest(arg0 *athena.BatchGetNamedQueryInput) (*request.Request, *athena.BatchGetNamedQueryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetNamedQueryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.BatchGetNamedQueryOutput) + return ret0, ret1 +} + +// BatchGetNamedQueryRequest indicates an expected call of BatchGetNamedQueryRequest +func (mr *MockAthenaAPIMockRecorder) BatchGetNamedQueryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetNamedQueryRequest", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetNamedQueryRequest), arg0) +} + +// BatchGetNamedQueryWithContext mocks base method +func (m *MockAthenaAPI) BatchGetNamedQueryWithContext(arg0 context.Context, arg1 *athena.BatchGetNamedQueryInput, arg2 ...request.Option) (*athena.BatchGetNamedQueryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchGetNamedQueryWithContext", varargs...) + ret0, _ := ret[0].(*athena.BatchGetNamedQueryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetNamedQueryWithContext indicates an expected call of BatchGetNamedQueryWithContext +func (mr *MockAthenaAPIMockRecorder) BatchGetNamedQueryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetNamedQueryWithContext), varargs...) +} + +// BatchGetQueryExecution mocks base method +func (m *MockAthenaAPI) BatchGetQueryExecution(arg0 *athena.BatchGetQueryExecutionInput) (*athena.BatchGetQueryExecutionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetQueryExecution", arg0) + ret0, _ := ret[0].(*athena.BatchGetQueryExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetQueryExecution indicates an expected call of BatchGetQueryExecution +func (mr *MockAthenaAPIMockRecorder) BatchGetQueryExecution(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetQueryExecution", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetQueryExecution), arg0) +} + +// BatchGetQueryExecutionRequest mocks base method +func (m *MockAthenaAPI) BatchGetQueryExecutionRequest(arg0 *athena.BatchGetQueryExecutionInput) (*request.Request, *athena.BatchGetQueryExecutionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetQueryExecutionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.BatchGetQueryExecutionOutput) + return ret0, ret1 +} + +// BatchGetQueryExecutionRequest indicates an expected call of BatchGetQueryExecutionRequest +func (mr *MockAthenaAPIMockRecorder) BatchGetQueryExecutionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetQueryExecutionRequest", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetQueryExecutionRequest), arg0) +} + +// BatchGetQueryExecutionWithContext mocks base method +func (m *MockAthenaAPI) BatchGetQueryExecutionWithContext(arg0 context.Context, arg1 *athena.BatchGetQueryExecutionInput, arg2 ...request.Option) (*athena.BatchGetQueryExecutionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchGetQueryExecutionWithContext", varargs...) + ret0, _ := ret[0].(*athena.BatchGetQueryExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetQueryExecutionWithContext indicates an expected call of BatchGetQueryExecutionWithContext +func (mr *MockAthenaAPIMockRecorder) BatchGetQueryExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetQueryExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetQueryExecutionWithContext), varargs...) +} + +// CreateDataCatalog mocks base method +func (m *MockAthenaAPI) CreateDataCatalog(arg0 *athena.CreateDataCatalogInput) (*athena.CreateDataCatalogOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateDataCatalog", arg0) + ret0, _ := ret[0].(*athena.CreateDataCatalogOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateDataCatalog indicates an expected call of CreateDataCatalog +func (mr *MockAthenaAPIMockRecorder) CreateDataCatalog(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDataCatalog", reflect.TypeOf((*MockAthenaAPI)(nil).CreateDataCatalog), arg0) +} + +// CreateDataCatalogRequest mocks base method +func (m *MockAthenaAPI) CreateDataCatalogRequest(arg0 *athena.CreateDataCatalogInput) (*request.Request, *athena.CreateDataCatalogOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateDataCatalogRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.CreateDataCatalogOutput) + return ret0, ret1 +} + +// CreateDataCatalogRequest indicates an expected call of CreateDataCatalogRequest +func (mr *MockAthenaAPIMockRecorder) CreateDataCatalogRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDataCatalogRequest", reflect.TypeOf((*MockAthenaAPI)(nil).CreateDataCatalogRequest), arg0) +} + +// CreateDataCatalogWithContext mocks base method +func (m *MockAthenaAPI) CreateDataCatalogWithContext(arg0 context.Context, arg1 *athena.CreateDataCatalogInput, arg2 ...request.Option) (*athena.CreateDataCatalogOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateDataCatalogWithContext", varargs...) + ret0, _ := ret[0].(*athena.CreateDataCatalogOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateDataCatalogWithContext indicates an expected call of CreateDataCatalogWithContext +func (mr *MockAthenaAPIMockRecorder) CreateDataCatalogWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDataCatalogWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreateDataCatalogWithContext), varargs...) +} + +// CreateNamedQuery mocks base method +func (m *MockAthenaAPI) CreateNamedQuery(arg0 *athena.CreateNamedQueryInput) (*athena.CreateNamedQueryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNamedQuery", arg0) + ret0, _ := ret[0].(*athena.CreateNamedQueryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNamedQuery indicates an expected call of CreateNamedQuery +func (mr *MockAthenaAPIMockRecorder) CreateNamedQuery(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamedQuery", reflect.TypeOf((*MockAthenaAPI)(nil).CreateNamedQuery), arg0) +} + +// CreateNamedQueryRequest mocks base method +func (m *MockAthenaAPI) CreateNamedQueryRequest(arg0 *athena.CreateNamedQueryInput) (*request.Request, *athena.CreateNamedQueryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNamedQueryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.CreateNamedQueryOutput) + return ret0, ret1 +} + +// CreateNamedQueryRequest indicates an expected call of CreateNamedQueryRequest +func (mr *MockAthenaAPIMockRecorder) CreateNamedQueryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamedQueryRequest", reflect.TypeOf((*MockAthenaAPI)(nil).CreateNamedQueryRequest), arg0) +} + +// CreateNamedQueryWithContext mocks base method +func (m *MockAthenaAPI) CreateNamedQueryWithContext(arg0 context.Context, arg1 *athena.CreateNamedQueryInput, arg2 ...request.Option) (*athena.CreateNamedQueryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateNamedQueryWithContext", varargs...) + ret0, _ := ret[0].(*athena.CreateNamedQueryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNamedQueryWithContext indicates an expected call of CreateNamedQueryWithContext +func (mr *MockAthenaAPIMockRecorder) CreateNamedQueryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreateNamedQueryWithContext), varargs...) +} + +// CreateWorkGroup mocks base method +func (m *MockAthenaAPI) CreateWorkGroup(arg0 *athena.CreateWorkGroupInput) (*athena.CreateWorkGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateWorkGroup", arg0) + ret0, _ := ret[0].(*athena.CreateWorkGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateWorkGroup indicates an expected call of CreateWorkGroup +func (mr *MockAthenaAPIMockRecorder) CreateWorkGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkGroup", reflect.TypeOf((*MockAthenaAPI)(nil).CreateWorkGroup), arg0) +} + +// CreateWorkGroupRequest mocks base method +func (m *MockAthenaAPI) CreateWorkGroupRequest(arg0 *athena.CreateWorkGroupInput) (*request.Request, *athena.CreateWorkGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateWorkGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.CreateWorkGroupOutput) + return ret0, ret1 +} + +// CreateWorkGroupRequest indicates an expected call of CreateWorkGroupRequest +func (mr *MockAthenaAPIMockRecorder) CreateWorkGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkGroupRequest", reflect.TypeOf((*MockAthenaAPI)(nil).CreateWorkGroupRequest), arg0) +} + +// CreateWorkGroupWithContext mocks base method +func (m *MockAthenaAPI) CreateWorkGroupWithContext(arg0 context.Context, arg1 *athena.CreateWorkGroupInput, arg2 ...request.Option) (*athena.CreateWorkGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateWorkGroupWithContext", varargs...) + ret0, _ := ret[0].(*athena.CreateWorkGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateWorkGroupWithContext indicates an expected call of CreateWorkGroupWithContext +func (mr *MockAthenaAPIMockRecorder) CreateWorkGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkGroupWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreateWorkGroupWithContext), varargs...) +} + +// DeleteDataCatalog mocks base method +func (m *MockAthenaAPI) DeleteDataCatalog(arg0 *athena.DeleteDataCatalogInput) (*athena.DeleteDataCatalogOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDataCatalog", arg0) + ret0, _ := ret[0].(*athena.DeleteDataCatalogOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDataCatalog indicates an expected call of DeleteDataCatalog +func (mr *MockAthenaAPIMockRecorder) DeleteDataCatalog(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDataCatalog", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteDataCatalog), arg0) +} + +// DeleteDataCatalogRequest mocks base method +func (m *MockAthenaAPI) DeleteDataCatalogRequest(arg0 *athena.DeleteDataCatalogInput) (*request.Request, *athena.DeleteDataCatalogOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDataCatalogRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.DeleteDataCatalogOutput) + return ret0, ret1 +} + +// DeleteDataCatalogRequest indicates an expected call of DeleteDataCatalogRequest +func (mr *MockAthenaAPIMockRecorder) DeleteDataCatalogRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDataCatalogRequest", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteDataCatalogRequest), arg0) +} + +// DeleteDataCatalogWithContext mocks base method +func (m *MockAthenaAPI) DeleteDataCatalogWithContext(arg0 context.Context, arg1 *athena.DeleteDataCatalogInput, arg2 ...request.Option) (*athena.DeleteDataCatalogOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteDataCatalogWithContext", varargs...) + ret0, _ := ret[0].(*athena.DeleteDataCatalogOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDataCatalogWithContext indicates an expected call of DeleteDataCatalogWithContext +func (mr *MockAthenaAPIMockRecorder) DeleteDataCatalogWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDataCatalogWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteDataCatalogWithContext), varargs...) +} + +// DeleteNamedQuery mocks base method +func (m *MockAthenaAPI) DeleteNamedQuery(arg0 *athena.DeleteNamedQueryInput) (*athena.DeleteNamedQueryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNamedQuery", arg0) + ret0, _ := ret[0].(*athena.DeleteNamedQueryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNamedQuery indicates an expected call of DeleteNamedQuery +func (mr *MockAthenaAPIMockRecorder) DeleteNamedQuery(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamedQuery", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteNamedQuery), arg0) +} + +// DeleteNamedQueryRequest mocks base method +func (m *MockAthenaAPI) DeleteNamedQueryRequest(arg0 *athena.DeleteNamedQueryInput) (*request.Request, *athena.DeleteNamedQueryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNamedQueryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.DeleteNamedQueryOutput) + return ret0, ret1 +} + +// DeleteNamedQueryRequest indicates an expected call of DeleteNamedQueryRequest +func (mr *MockAthenaAPIMockRecorder) DeleteNamedQueryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamedQueryRequest", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteNamedQueryRequest), arg0) +} + +// DeleteNamedQueryWithContext mocks base method +func (m *MockAthenaAPI) DeleteNamedQueryWithContext(arg0 context.Context, arg1 *athena.DeleteNamedQueryInput, arg2 ...request.Option) (*athena.DeleteNamedQueryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNamedQueryWithContext", varargs...) + ret0, _ := ret[0].(*athena.DeleteNamedQueryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNamedQueryWithContext indicates an expected call of DeleteNamedQueryWithContext +func (mr *MockAthenaAPIMockRecorder) DeleteNamedQueryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteNamedQueryWithContext), varargs...) +} + +// DeleteWorkGroup mocks base method +func (m *MockAthenaAPI) DeleteWorkGroup(arg0 *athena.DeleteWorkGroupInput) (*athena.DeleteWorkGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteWorkGroup", arg0) + ret0, _ := ret[0].(*athena.DeleteWorkGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteWorkGroup indicates an expected call of DeleteWorkGroup +func (mr *MockAthenaAPIMockRecorder) DeleteWorkGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkGroup", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteWorkGroup), arg0) +} + +// DeleteWorkGroupRequest mocks base method +func (m *MockAthenaAPI) DeleteWorkGroupRequest(arg0 *athena.DeleteWorkGroupInput) (*request.Request, *athena.DeleteWorkGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteWorkGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.DeleteWorkGroupOutput) + return ret0, ret1 +} + +// DeleteWorkGroupRequest indicates an expected call of DeleteWorkGroupRequest +func (mr *MockAthenaAPIMockRecorder) DeleteWorkGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkGroupRequest", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteWorkGroupRequest), arg0) +} + +// DeleteWorkGroupWithContext mocks base method +func (m *MockAthenaAPI) DeleteWorkGroupWithContext(arg0 context.Context, arg1 *athena.DeleteWorkGroupInput, arg2 ...request.Option) (*athena.DeleteWorkGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteWorkGroupWithContext", varargs...) + ret0, _ := ret[0].(*athena.DeleteWorkGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteWorkGroupWithContext indicates an expected call of DeleteWorkGroupWithContext +func (mr *MockAthenaAPIMockRecorder) DeleteWorkGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkGroupWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteWorkGroupWithContext), varargs...) +} + +// GetDataCatalog mocks base method +func (m *MockAthenaAPI) GetDataCatalog(arg0 *athena.GetDataCatalogInput) (*athena.GetDataCatalogOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDataCatalog", arg0) + ret0, _ := ret[0].(*athena.GetDataCatalogOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDataCatalog indicates an expected call of GetDataCatalog +func (mr *MockAthenaAPIMockRecorder) GetDataCatalog(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCatalog", reflect.TypeOf((*MockAthenaAPI)(nil).GetDataCatalog), arg0) +} + +// GetDataCatalogRequest mocks base method +func (m *MockAthenaAPI) GetDataCatalogRequest(arg0 *athena.GetDataCatalogInput) (*request.Request, *athena.GetDataCatalogOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDataCatalogRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.GetDataCatalogOutput) + return ret0, ret1 +} + +// GetDataCatalogRequest indicates an expected call of GetDataCatalogRequest +func (mr *MockAthenaAPIMockRecorder) GetDataCatalogRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCatalogRequest", reflect.TypeOf((*MockAthenaAPI)(nil).GetDataCatalogRequest), arg0) +} + +// GetDataCatalogWithContext mocks base method +func (m *MockAthenaAPI) GetDataCatalogWithContext(arg0 context.Context, arg1 *athena.GetDataCatalogInput, arg2 ...request.Option) (*athena.GetDataCatalogOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetDataCatalogWithContext", varargs...) + ret0, _ := ret[0].(*athena.GetDataCatalogOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDataCatalogWithContext indicates an expected call of GetDataCatalogWithContext +func (mr *MockAthenaAPIMockRecorder) GetDataCatalogWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCatalogWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetDataCatalogWithContext), varargs...) +} + +// GetDatabase mocks base method +func (m *MockAthenaAPI) GetDatabase(arg0 *athena.GetDatabaseInput) (*athena.GetDatabaseOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDatabase", arg0) + ret0, _ := ret[0].(*athena.GetDatabaseOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDatabase indicates an expected call of GetDatabase +func (mr *MockAthenaAPIMockRecorder) GetDatabase(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDatabase", reflect.TypeOf((*MockAthenaAPI)(nil).GetDatabase), arg0) +} + +// GetDatabaseRequest mocks base method +func (m *MockAthenaAPI) GetDatabaseRequest(arg0 *athena.GetDatabaseInput) (*request.Request, *athena.GetDatabaseOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDatabaseRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.GetDatabaseOutput) + return ret0, ret1 +} + +// GetDatabaseRequest indicates an expected call of GetDatabaseRequest +func (mr *MockAthenaAPIMockRecorder) GetDatabaseRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDatabaseRequest", reflect.TypeOf((*MockAthenaAPI)(nil).GetDatabaseRequest), arg0) +} + +// GetDatabaseWithContext mocks base method +func (m *MockAthenaAPI) GetDatabaseWithContext(arg0 context.Context, arg1 *athena.GetDatabaseInput, arg2 ...request.Option) (*athena.GetDatabaseOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetDatabaseWithContext", varargs...) + ret0, _ := ret[0].(*athena.GetDatabaseOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDatabaseWithContext indicates an expected call of GetDatabaseWithContext +func (mr *MockAthenaAPIMockRecorder) GetDatabaseWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDatabaseWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetDatabaseWithContext), varargs...) +} + +// GetNamedQuery mocks base method +func (m *MockAthenaAPI) GetNamedQuery(arg0 *athena.GetNamedQueryInput) (*athena.GetNamedQueryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNamedQuery", arg0) + ret0, _ := ret[0].(*athena.GetNamedQueryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNamedQuery indicates an expected call of GetNamedQuery +func (mr *MockAthenaAPIMockRecorder) GetNamedQuery(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamedQuery", reflect.TypeOf((*MockAthenaAPI)(nil).GetNamedQuery), arg0) +} + +// GetNamedQueryRequest mocks base method +func (m *MockAthenaAPI) GetNamedQueryRequest(arg0 *athena.GetNamedQueryInput) (*request.Request, *athena.GetNamedQueryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNamedQueryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.GetNamedQueryOutput) + return ret0, ret1 +} + +// GetNamedQueryRequest indicates an expected call of GetNamedQueryRequest +func (mr *MockAthenaAPIMockRecorder) GetNamedQueryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamedQueryRequest", reflect.TypeOf((*MockAthenaAPI)(nil).GetNamedQueryRequest), arg0) +} + +// GetNamedQueryWithContext mocks base method +func (m *MockAthenaAPI) GetNamedQueryWithContext(arg0 context.Context, arg1 *athena.GetNamedQueryInput, arg2 ...request.Option) (*athena.GetNamedQueryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetNamedQueryWithContext", varargs...) + ret0, _ := ret[0].(*athena.GetNamedQueryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNamedQueryWithContext indicates an expected call of GetNamedQueryWithContext +func (mr *MockAthenaAPIMockRecorder) GetNamedQueryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetNamedQueryWithContext), varargs...) +} + +// GetQueryExecution mocks base method +func (m *MockAthenaAPI) GetQueryExecution(arg0 *athena.GetQueryExecutionInput) (*athena.GetQueryExecutionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryExecution", arg0) + ret0, _ := ret[0].(*athena.GetQueryExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueryExecution indicates an expected call of GetQueryExecution +func (mr *MockAthenaAPIMockRecorder) GetQueryExecution(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryExecution", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryExecution), arg0) +} + +// GetQueryExecutionRequest mocks base method +func (m *MockAthenaAPI) GetQueryExecutionRequest(arg0 *athena.GetQueryExecutionInput) (*request.Request, *athena.GetQueryExecutionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryExecutionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.GetQueryExecutionOutput) + return ret0, ret1 +} + +// GetQueryExecutionRequest indicates an expected call of GetQueryExecutionRequest +func (mr *MockAthenaAPIMockRecorder) GetQueryExecutionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryExecutionRequest", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryExecutionRequest), arg0) +} + +// GetQueryExecutionWithContext mocks base method +func (m *MockAthenaAPI) GetQueryExecutionWithContext(arg0 context.Context, arg1 *athena.GetQueryExecutionInput, arg2 ...request.Option) (*athena.GetQueryExecutionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetQueryExecutionWithContext", varargs...) + ret0, _ := ret[0].(*athena.GetQueryExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueryExecutionWithContext indicates an expected call of GetQueryExecutionWithContext +func (mr *MockAthenaAPIMockRecorder) GetQueryExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryExecutionWithContext), varargs...) +} + +// GetQueryResults mocks base method +func (m *MockAthenaAPI) GetQueryResults(arg0 *athena.GetQueryResultsInput) (*athena.GetQueryResultsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryResults", arg0) + ret0, _ := ret[0].(*athena.GetQueryResultsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueryResults indicates an expected call of GetQueryResults +func (mr *MockAthenaAPIMockRecorder) GetQueryResults(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryResults", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryResults), arg0) +} + +// GetQueryResultsPages mocks base method +func (m *MockAthenaAPI) GetQueryResultsPages(arg0 *athena.GetQueryResultsInput, arg1 func(*athena.GetQueryResultsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryResultsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetQueryResultsPages indicates an expected call of GetQueryResultsPages +func (mr *MockAthenaAPIMockRecorder) GetQueryResultsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryResultsPages", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryResultsPages), arg0, arg1) +} + +// GetQueryResultsPagesWithContext mocks base method +func (m *MockAthenaAPI) GetQueryResultsPagesWithContext(arg0 context.Context, arg1 *athena.GetQueryResultsInput, arg2 func(*athena.GetQueryResultsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetQueryResultsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetQueryResultsPagesWithContext indicates an expected call of GetQueryResultsPagesWithContext +func (mr *MockAthenaAPIMockRecorder) GetQueryResultsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryResultsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryResultsPagesWithContext), varargs...) +} + +// GetQueryResultsRequest mocks base method +func (m *MockAthenaAPI) GetQueryResultsRequest(arg0 *athena.GetQueryResultsInput) (*request.Request, *athena.GetQueryResultsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryResultsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.GetQueryResultsOutput) + return ret0, ret1 +} + +// GetQueryResultsRequest indicates an expected call of GetQueryResultsRequest +func (mr *MockAthenaAPIMockRecorder) GetQueryResultsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryResultsRequest", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryResultsRequest), arg0) +} + +// GetQueryResultsWithContext mocks base method +func (m *MockAthenaAPI) GetQueryResultsWithContext(arg0 context.Context, arg1 *athena.GetQueryResultsInput, arg2 ...request.Option) (*athena.GetQueryResultsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetQueryResultsWithContext", varargs...) + ret0, _ := ret[0].(*athena.GetQueryResultsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetQueryResultsWithContext indicates an expected call of GetQueryResultsWithContext +func (mr *MockAthenaAPIMockRecorder) GetQueryResultsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryResultsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryResultsWithContext), varargs...) +} + +// GetTableMetadata mocks base method +func (m *MockAthenaAPI) GetTableMetadata(arg0 *athena.GetTableMetadataInput) (*athena.GetTableMetadataOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTableMetadata", arg0) + ret0, _ := ret[0].(*athena.GetTableMetadataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTableMetadata indicates an expected call of GetTableMetadata +func (mr *MockAthenaAPIMockRecorder) GetTableMetadata(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTableMetadata", reflect.TypeOf((*MockAthenaAPI)(nil).GetTableMetadata), arg0) +} + +// GetTableMetadataRequest mocks base method +func (m *MockAthenaAPI) GetTableMetadataRequest(arg0 *athena.GetTableMetadataInput) (*request.Request, *athena.GetTableMetadataOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTableMetadataRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.GetTableMetadataOutput) + return ret0, ret1 +} + +// GetTableMetadataRequest indicates an expected call of GetTableMetadataRequest +func (mr *MockAthenaAPIMockRecorder) GetTableMetadataRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTableMetadataRequest", reflect.TypeOf((*MockAthenaAPI)(nil).GetTableMetadataRequest), arg0) +} + +// GetTableMetadataWithContext mocks base method +func (m *MockAthenaAPI) GetTableMetadataWithContext(arg0 context.Context, arg1 *athena.GetTableMetadataInput, arg2 ...request.Option) (*athena.GetTableMetadataOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTableMetadataWithContext", varargs...) + ret0, _ := ret[0].(*athena.GetTableMetadataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTableMetadataWithContext indicates an expected call of GetTableMetadataWithContext +func (mr *MockAthenaAPIMockRecorder) GetTableMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTableMetadataWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetTableMetadataWithContext), varargs...) +} + +// GetWorkGroup mocks base method +func (m *MockAthenaAPI) GetWorkGroup(arg0 *athena.GetWorkGroupInput) (*athena.GetWorkGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWorkGroup", arg0) + ret0, _ := ret[0].(*athena.GetWorkGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWorkGroup indicates an expected call of GetWorkGroup +func (mr *MockAthenaAPIMockRecorder) GetWorkGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkGroup", reflect.TypeOf((*MockAthenaAPI)(nil).GetWorkGroup), arg0) +} + +// GetWorkGroupRequest mocks base method +func (m *MockAthenaAPI) GetWorkGroupRequest(arg0 *athena.GetWorkGroupInput) (*request.Request, *athena.GetWorkGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWorkGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.GetWorkGroupOutput) + return ret0, ret1 +} + +// GetWorkGroupRequest indicates an expected call of GetWorkGroupRequest +func (mr *MockAthenaAPIMockRecorder) GetWorkGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkGroupRequest", reflect.TypeOf((*MockAthenaAPI)(nil).GetWorkGroupRequest), arg0) +} + +// GetWorkGroupWithContext mocks base method +func (m *MockAthenaAPI) GetWorkGroupWithContext(arg0 context.Context, arg1 *athena.GetWorkGroupInput, arg2 ...request.Option) (*athena.GetWorkGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetWorkGroupWithContext", varargs...) + ret0, _ := ret[0].(*athena.GetWorkGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWorkGroupWithContext indicates an expected call of GetWorkGroupWithContext +func (mr *MockAthenaAPIMockRecorder) GetWorkGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkGroupWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetWorkGroupWithContext), varargs...) +} + +// ListDataCatalogs mocks base method +func (m *MockAthenaAPI) ListDataCatalogs(arg0 *athena.ListDataCatalogsInput) (*athena.ListDataCatalogsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDataCatalogs", arg0) + ret0, _ := ret[0].(*athena.ListDataCatalogsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDataCatalogs indicates an expected call of ListDataCatalogs +func (mr *MockAthenaAPIMockRecorder) ListDataCatalogs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDataCatalogs", reflect.TypeOf((*MockAthenaAPI)(nil).ListDataCatalogs), arg0) +} + +// ListDataCatalogsPages mocks base method +func (m *MockAthenaAPI) ListDataCatalogsPages(arg0 *athena.ListDataCatalogsInput, arg1 func(*athena.ListDataCatalogsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDataCatalogsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListDataCatalogsPages indicates an expected call of ListDataCatalogsPages +func (mr *MockAthenaAPIMockRecorder) ListDataCatalogsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDataCatalogsPages", reflect.TypeOf((*MockAthenaAPI)(nil).ListDataCatalogsPages), arg0, arg1) +} + +// ListDataCatalogsPagesWithContext mocks base method +func (m *MockAthenaAPI) ListDataCatalogsPagesWithContext(arg0 context.Context, arg1 *athena.ListDataCatalogsInput, arg2 func(*athena.ListDataCatalogsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDataCatalogsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListDataCatalogsPagesWithContext indicates an expected call of ListDataCatalogsPagesWithContext +func (mr *MockAthenaAPIMockRecorder) ListDataCatalogsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDataCatalogsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListDataCatalogsPagesWithContext), varargs...) +} + +// ListDataCatalogsRequest mocks base method +func (m *MockAthenaAPI) ListDataCatalogsRequest(arg0 *athena.ListDataCatalogsInput) (*request.Request, *athena.ListDataCatalogsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDataCatalogsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.ListDataCatalogsOutput) + return ret0, ret1 +} + +// ListDataCatalogsRequest indicates an expected call of ListDataCatalogsRequest +func (mr *MockAthenaAPIMockRecorder) ListDataCatalogsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDataCatalogsRequest", reflect.TypeOf((*MockAthenaAPI)(nil).ListDataCatalogsRequest), arg0) +} + +// ListDataCatalogsWithContext mocks base method +func (m *MockAthenaAPI) ListDataCatalogsWithContext(arg0 context.Context, arg1 *athena.ListDataCatalogsInput, arg2 ...request.Option) (*athena.ListDataCatalogsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDataCatalogsWithContext", varargs...) + ret0, _ := ret[0].(*athena.ListDataCatalogsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDataCatalogsWithContext indicates an expected call of ListDataCatalogsWithContext +func (mr *MockAthenaAPIMockRecorder) ListDataCatalogsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDataCatalogsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListDataCatalogsWithContext), varargs...) +} + +// ListDatabases mocks base method +func (m *MockAthenaAPI) ListDatabases(arg0 *athena.ListDatabasesInput) (*athena.ListDatabasesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDatabases", arg0) + ret0, _ := ret[0].(*athena.ListDatabasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDatabases indicates an expected call of ListDatabases +func (mr *MockAthenaAPIMockRecorder) ListDatabases(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabases", reflect.TypeOf((*MockAthenaAPI)(nil).ListDatabases), arg0) +} + +// ListDatabasesPages mocks base method +func (m *MockAthenaAPI) ListDatabasesPages(arg0 *athena.ListDatabasesInput, arg1 func(*athena.ListDatabasesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDatabasesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListDatabasesPages indicates an expected call of ListDatabasesPages +func (mr *MockAthenaAPIMockRecorder) ListDatabasesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabasesPages", reflect.TypeOf((*MockAthenaAPI)(nil).ListDatabasesPages), arg0, arg1) +} + +// ListDatabasesPagesWithContext mocks base method +func (m *MockAthenaAPI) ListDatabasesPagesWithContext(arg0 context.Context, arg1 *athena.ListDatabasesInput, arg2 func(*athena.ListDatabasesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDatabasesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListDatabasesPagesWithContext indicates an expected call of ListDatabasesPagesWithContext +func (mr *MockAthenaAPIMockRecorder) ListDatabasesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabasesPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListDatabasesPagesWithContext), varargs...) +} + +// ListDatabasesRequest mocks base method +func (m *MockAthenaAPI) ListDatabasesRequest(arg0 *athena.ListDatabasesInput) (*request.Request, *athena.ListDatabasesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDatabasesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.ListDatabasesOutput) + return ret0, ret1 +} + +// ListDatabasesRequest indicates an expected call of ListDatabasesRequest +func (mr *MockAthenaAPIMockRecorder) ListDatabasesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabasesRequest", reflect.TypeOf((*MockAthenaAPI)(nil).ListDatabasesRequest), arg0) +} + +// ListDatabasesWithContext mocks base method +func (m *MockAthenaAPI) ListDatabasesWithContext(arg0 context.Context, arg1 *athena.ListDatabasesInput, arg2 ...request.Option) (*athena.ListDatabasesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDatabasesWithContext", varargs...) + ret0, _ := ret[0].(*athena.ListDatabasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDatabasesWithContext indicates an expected call of ListDatabasesWithContext +func (mr *MockAthenaAPIMockRecorder) ListDatabasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabasesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListDatabasesWithContext), varargs...) +} + +// ListNamedQueries mocks base method +func (m *MockAthenaAPI) ListNamedQueries(arg0 *athena.ListNamedQueriesInput) (*athena.ListNamedQueriesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNamedQueries", arg0) + ret0, _ := ret[0].(*athena.ListNamedQueriesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListNamedQueries indicates an expected call of ListNamedQueries +func (mr *MockAthenaAPIMockRecorder) ListNamedQueries(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamedQueries", reflect.TypeOf((*MockAthenaAPI)(nil).ListNamedQueries), arg0) +} + +// ListNamedQueriesPages mocks base method +func (m *MockAthenaAPI) ListNamedQueriesPages(arg0 *athena.ListNamedQueriesInput, arg1 func(*athena.ListNamedQueriesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNamedQueriesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListNamedQueriesPages indicates an expected call of ListNamedQueriesPages +func (mr *MockAthenaAPIMockRecorder) ListNamedQueriesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamedQueriesPages", reflect.TypeOf((*MockAthenaAPI)(nil).ListNamedQueriesPages), arg0, arg1) +} + +// ListNamedQueriesPagesWithContext mocks base method +func (m *MockAthenaAPI) ListNamedQueriesPagesWithContext(arg0 context.Context, arg1 *athena.ListNamedQueriesInput, arg2 func(*athena.ListNamedQueriesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListNamedQueriesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListNamedQueriesPagesWithContext indicates an expected call of ListNamedQueriesPagesWithContext +func (mr *MockAthenaAPIMockRecorder) ListNamedQueriesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamedQueriesPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListNamedQueriesPagesWithContext), varargs...) +} + +// ListNamedQueriesRequest mocks base method +func (m *MockAthenaAPI) ListNamedQueriesRequest(arg0 *athena.ListNamedQueriesInput) (*request.Request, *athena.ListNamedQueriesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNamedQueriesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.ListNamedQueriesOutput) + return ret0, ret1 +} + +// ListNamedQueriesRequest indicates an expected call of ListNamedQueriesRequest +func (mr *MockAthenaAPIMockRecorder) ListNamedQueriesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamedQueriesRequest", reflect.TypeOf((*MockAthenaAPI)(nil).ListNamedQueriesRequest), arg0) +} + +// ListNamedQueriesWithContext mocks base method +func (m *MockAthenaAPI) ListNamedQueriesWithContext(arg0 context.Context, arg1 *athena.ListNamedQueriesInput, arg2 ...request.Option) (*athena.ListNamedQueriesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListNamedQueriesWithContext", varargs...) + ret0, _ := ret[0].(*athena.ListNamedQueriesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListNamedQueriesWithContext indicates an expected call of ListNamedQueriesWithContext +func (mr *MockAthenaAPIMockRecorder) ListNamedQueriesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamedQueriesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListNamedQueriesWithContext), varargs...) +} + +// ListQueryExecutions mocks base method +func (m *MockAthenaAPI) ListQueryExecutions(arg0 *athena.ListQueryExecutionsInput) (*athena.ListQueryExecutionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListQueryExecutions", arg0) + ret0, _ := ret[0].(*athena.ListQueryExecutionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListQueryExecutions indicates an expected call of ListQueryExecutions +func (mr *MockAthenaAPIMockRecorder) ListQueryExecutions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryExecutions", reflect.TypeOf((*MockAthenaAPI)(nil).ListQueryExecutions), arg0) +} + +// ListQueryExecutionsPages mocks base method +func (m *MockAthenaAPI) ListQueryExecutionsPages(arg0 *athena.ListQueryExecutionsInput, arg1 func(*athena.ListQueryExecutionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListQueryExecutionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListQueryExecutionsPages indicates an expected call of ListQueryExecutionsPages +func (mr *MockAthenaAPIMockRecorder) ListQueryExecutionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryExecutionsPages", reflect.TypeOf((*MockAthenaAPI)(nil).ListQueryExecutionsPages), arg0, arg1) +} + +// ListQueryExecutionsPagesWithContext mocks base method +func (m *MockAthenaAPI) ListQueryExecutionsPagesWithContext(arg0 context.Context, arg1 *athena.ListQueryExecutionsInput, arg2 func(*athena.ListQueryExecutionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListQueryExecutionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListQueryExecutionsPagesWithContext indicates an expected call of ListQueryExecutionsPagesWithContext +func (mr *MockAthenaAPIMockRecorder) ListQueryExecutionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryExecutionsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListQueryExecutionsPagesWithContext), varargs...) +} + +// ListQueryExecutionsRequest mocks base method +func (m *MockAthenaAPI) ListQueryExecutionsRequest(arg0 *athena.ListQueryExecutionsInput) (*request.Request, *athena.ListQueryExecutionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListQueryExecutionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.ListQueryExecutionsOutput) + return ret0, ret1 +} + +// ListQueryExecutionsRequest indicates an expected call of ListQueryExecutionsRequest +func (mr *MockAthenaAPIMockRecorder) ListQueryExecutionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryExecutionsRequest", reflect.TypeOf((*MockAthenaAPI)(nil).ListQueryExecutionsRequest), arg0) +} + +// ListQueryExecutionsWithContext mocks base method +func (m *MockAthenaAPI) ListQueryExecutionsWithContext(arg0 context.Context, arg1 *athena.ListQueryExecutionsInput, arg2 ...request.Option) (*athena.ListQueryExecutionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListQueryExecutionsWithContext", varargs...) + ret0, _ := ret[0].(*athena.ListQueryExecutionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListQueryExecutionsWithContext indicates an expected call of ListQueryExecutionsWithContext +func (mr *MockAthenaAPIMockRecorder) ListQueryExecutionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryExecutionsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListQueryExecutionsWithContext), varargs...) +} + +// ListTableMetadata mocks base method +func (m *MockAthenaAPI) ListTableMetadata(arg0 *athena.ListTableMetadataInput) (*athena.ListTableMetadataOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTableMetadata", arg0) + ret0, _ := ret[0].(*athena.ListTableMetadataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTableMetadata indicates an expected call of ListTableMetadata +func (mr *MockAthenaAPIMockRecorder) ListTableMetadata(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTableMetadata", reflect.TypeOf((*MockAthenaAPI)(nil).ListTableMetadata), arg0) +} + +// ListTableMetadataPages mocks base method +func (m *MockAthenaAPI) ListTableMetadataPages(arg0 *athena.ListTableMetadataInput, arg1 func(*athena.ListTableMetadataOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTableMetadataPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTableMetadataPages indicates an expected call of ListTableMetadataPages +func (mr *MockAthenaAPIMockRecorder) ListTableMetadataPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTableMetadataPages", reflect.TypeOf((*MockAthenaAPI)(nil).ListTableMetadataPages), arg0, arg1) +} + +// ListTableMetadataPagesWithContext mocks base method +func (m *MockAthenaAPI) ListTableMetadataPagesWithContext(arg0 context.Context, arg1 *athena.ListTableMetadataInput, arg2 func(*athena.ListTableMetadataOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTableMetadataPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTableMetadataPagesWithContext indicates an expected call of ListTableMetadataPagesWithContext +func (mr *MockAthenaAPIMockRecorder) ListTableMetadataPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTableMetadataPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListTableMetadataPagesWithContext), varargs...) +} + +// ListTableMetadataRequest mocks base method +func (m *MockAthenaAPI) ListTableMetadataRequest(arg0 *athena.ListTableMetadataInput) (*request.Request, *athena.ListTableMetadataOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTableMetadataRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.ListTableMetadataOutput) + return ret0, ret1 +} + +// ListTableMetadataRequest indicates an expected call of ListTableMetadataRequest +func (mr *MockAthenaAPIMockRecorder) ListTableMetadataRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTableMetadataRequest", reflect.TypeOf((*MockAthenaAPI)(nil).ListTableMetadataRequest), arg0) +} + +// ListTableMetadataWithContext mocks base method +func (m *MockAthenaAPI) ListTableMetadataWithContext(arg0 context.Context, arg1 *athena.ListTableMetadataInput, arg2 ...request.Option) (*athena.ListTableMetadataOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTableMetadataWithContext", varargs...) + ret0, _ := ret[0].(*athena.ListTableMetadataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTableMetadataWithContext indicates an expected call of ListTableMetadataWithContext +func (mr *MockAthenaAPIMockRecorder) ListTableMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTableMetadataWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListTableMetadataWithContext), varargs...) +} + +// ListTagsForResource mocks base method +func (m *MockAthenaAPI) ListTagsForResource(arg0 *athena.ListTagsForResourceInput) (*athena.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResource", arg0) + ret0, _ := ret[0].(*athena.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResource indicates an expected call of ListTagsForResource +func (mr *MockAthenaAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockAthenaAPI)(nil).ListTagsForResource), arg0) +} + +// ListTagsForResourcePages mocks base method +func (m *MockAthenaAPI) ListTagsForResourcePages(arg0 *athena.ListTagsForResourceInput, arg1 func(*athena.ListTagsForResourceOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourcePages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTagsForResourcePages indicates an expected call of ListTagsForResourcePages +func (mr *MockAthenaAPIMockRecorder) ListTagsForResourcePages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcePages", reflect.TypeOf((*MockAthenaAPI)(nil).ListTagsForResourcePages), arg0, arg1) +} + +// ListTagsForResourcePagesWithContext mocks base method +func (m *MockAthenaAPI) ListTagsForResourcePagesWithContext(arg0 context.Context, arg1 *athena.ListTagsForResourceInput, arg2 func(*athena.ListTagsForResourceOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsForResourcePagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTagsForResourcePagesWithContext indicates an expected call of ListTagsForResourcePagesWithContext +func (mr *MockAthenaAPIMockRecorder) ListTagsForResourcePagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcePagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListTagsForResourcePagesWithContext), varargs...) +} + +// ListTagsForResourceRequest mocks base method +func (m *MockAthenaAPI) ListTagsForResourceRequest(arg0 *athena.ListTagsForResourceInput) (*request.Request, *athena.ListTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.ListTagsForResourceOutput) + return ret0, ret1 +} + +// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest +func (mr *MockAthenaAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockAthenaAPI)(nil).ListTagsForResourceRequest), arg0) +} + +// ListTagsForResourceWithContext mocks base method +func (m *MockAthenaAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *athena.ListTagsForResourceInput, arg2 ...request.Option) (*athena.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) + ret0, _ := ret[0].(*athena.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext +func (mr *MockAthenaAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListTagsForResourceWithContext), varargs...) +} + +// ListWorkGroups mocks base method +func (m *MockAthenaAPI) ListWorkGroups(arg0 *athena.ListWorkGroupsInput) (*athena.ListWorkGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListWorkGroups", arg0) + ret0, _ := ret[0].(*athena.ListWorkGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListWorkGroups indicates an expected call of ListWorkGroups +func (mr *MockAthenaAPIMockRecorder) ListWorkGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkGroups", reflect.TypeOf((*MockAthenaAPI)(nil).ListWorkGroups), arg0) +} + +// ListWorkGroupsPages mocks base method +func (m *MockAthenaAPI) ListWorkGroupsPages(arg0 *athena.ListWorkGroupsInput, arg1 func(*athena.ListWorkGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListWorkGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListWorkGroupsPages indicates an expected call of ListWorkGroupsPages +func (mr *MockAthenaAPIMockRecorder) ListWorkGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkGroupsPages", reflect.TypeOf((*MockAthenaAPI)(nil).ListWorkGroupsPages), arg0, arg1) +} + +// ListWorkGroupsPagesWithContext mocks base method +func (m *MockAthenaAPI) ListWorkGroupsPagesWithContext(arg0 context.Context, arg1 *athena.ListWorkGroupsInput, arg2 func(*athena.ListWorkGroupsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListWorkGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListWorkGroupsPagesWithContext indicates an expected call of ListWorkGroupsPagesWithContext +func (mr *MockAthenaAPIMockRecorder) ListWorkGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkGroupsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListWorkGroupsPagesWithContext), varargs...) +} + +// ListWorkGroupsRequest mocks base method +func (m *MockAthenaAPI) ListWorkGroupsRequest(arg0 *athena.ListWorkGroupsInput) (*request.Request, *athena.ListWorkGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListWorkGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.ListWorkGroupsOutput) + return ret0, ret1 +} + +// ListWorkGroupsRequest indicates an expected call of ListWorkGroupsRequest +func (mr *MockAthenaAPIMockRecorder) ListWorkGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkGroupsRequest", reflect.TypeOf((*MockAthenaAPI)(nil).ListWorkGroupsRequest), arg0) +} + +// ListWorkGroupsWithContext mocks base method +func (m *MockAthenaAPI) ListWorkGroupsWithContext(arg0 context.Context, arg1 *athena.ListWorkGroupsInput, arg2 ...request.Option) (*athena.ListWorkGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListWorkGroupsWithContext", varargs...) + ret0, _ := ret[0].(*athena.ListWorkGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListWorkGroupsWithContext indicates an expected call of ListWorkGroupsWithContext +func (mr *MockAthenaAPIMockRecorder) ListWorkGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkGroupsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListWorkGroupsWithContext), varargs...) +} + +// StartQueryExecution mocks base method +func (m *MockAthenaAPI) StartQueryExecution(arg0 *athena.StartQueryExecutionInput) (*athena.StartQueryExecutionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartQueryExecution", arg0) + ret0, _ := ret[0].(*athena.StartQueryExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartQueryExecution indicates an expected call of StartQueryExecution +func (mr *MockAthenaAPIMockRecorder) StartQueryExecution(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartQueryExecution", reflect.TypeOf((*MockAthenaAPI)(nil).StartQueryExecution), arg0) +} + +// StartQueryExecutionRequest mocks base method +func (m *MockAthenaAPI) StartQueryExecutionRequest(arg0 *athena.StartQueryExecutionInput) (*request.Request, *athena.StartQueryExecutionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartQueryExecutionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.StartQueryExecutionOutput) + return ret0, ret1 +} + +// StartQueryExecutionRequest indicates an expected call of StartQueryExecutionRequest +func (mr *MockAthenaAPIMockRecorder) StartQueryExecutionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartQueryExecutionRequest", reflect.TypeOf((*MockAthenaAPI)(nil).StartQueryExecutionRequest), arg0) +} + +// StartQueryExecutionWithContext mocks base method +func (m *MockAthenaAPI) StartQueryExecutionWithContext(arg0 context.Context, arg1 *athena.StartQueryExecutionInput, arg2 ...request.Option) (*athena.StartQueryExecutionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartQueryExecutionWithContext", varargs...) + ret0, _ := ret[0].(*athena.StartQueryExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartQueryExecutionWithContext indicates an expected call of StartQueryExecutionWithContext +func (mr *MockAthenaAPIMockRecorder) StartQueryExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartQueryExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).StartQueryExecutionWithContext), varargs...) +} + +// StopQueryExecution mocks base method +func (m *MockAthenaAPI) StopQueryExecution(arg0 *athena.StopQueryExecutionInput) (*athena.StopQueryExecutionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopQueryExecution", arg0) + ret0, _ := ret[0].(*athena.StopQueryExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopQueryExecution indicates an expected call of StopQueryExecution +func (mr *MockAthenaAPIMockRecorder) StopQueryExecution(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopQueryExecution", reflect.TypeOf((*MockAthenaAPI)(nil).StopQueryExecution), arg0) +} + +// StopQueryExecutionRequest mocks base method +func (m *MockAthenaAPI) StopQueryExecutionRequest(arg0 *athena.StopQueryExecutionInput) (*request.Request, *athena.StopQueryExecutionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopQueryExecutionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.StopQueryExecutionOutput) + return ret0, ret1 +} + +// StopQueryExecutionRequest indicates an expected call of StopQueryExecutionRequest +func (mr *MockAthenaAPIMockRecorder) StopQueryExecutionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopQueryExecutionRequest", reflect.TypeOf((*MockAthenaAPI)(nil).StopQueryExecutionRequest), arg0) +} + +// StopQueryExecutionWithContext mocks base method +func (m *MockAthenaAPI) StopQueryExecutionWithContext(arg0 context.Context, arg1 *athena.StopQueryExecutionInput, arg2 ...request.Option) (*athena.StopQueryExecutionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StopQueryExecutionWithContext", varargs...) + ret0, _ := ret[0].(*athena.StopQueryExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopQueryExecutionWithContext indicates an expected call of StopQueryExecutionWithContext +func (mr *MockAthenaAPIMockRecorder) StopQueryExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopQueryExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).StopQueryExecutionWithContext), varargs...) +} + +// TagResource mocks base method +func (m *MockAthenaAPI) TagResource(arg0 *athena.TagResourceInput) (*athena.TagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResource", arg0) + ret0, _ := ret[0].(*athena.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResource indicates an expected call of TagResource +func (mr *MockAthenaAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockAthenaAPI)(nil).TagResource), arg0) +} + +// TagResourceRequest mocks base method +func (m *MockAthenaAPI) TagResourceRequest(arg0 *athena.TagResourceInput) (*request.Request, *athena.TagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.TagResourceOutput) + return ret0, ret1 +} + +// TagResourceRequest indicates an expected call of TagResourceRequest +func (mr *MockAthenaAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockAthenaAPI)(nil).TagResourceRequest), arg0) +} + +// TagResourceWithContext mocks base method +func (m *MockAthenaAPI) TagResourceWithContext(arg0 context.Context, arg1 *athena.TagResourceInput, arg2 ...request.Option) (*athena.TagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) + ret0, _ := ret[0].(*athena.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResourceWithContext indicates an expected call of TagResourceWithContext +func (mr *MockAthenaAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).TagResourceWithContext), varargs...) +} + +// UntagResource mocks base method +func (m *MockAthenaAPI) UntagResource(arg0 *athena.UntagResourceInput) (*athena.UntagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResource", arg0) + ret0, _ := ret[0].(*athena.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResource indicates an expected call of UntagResource +func (mr *MockAthenaAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockAthenaAPI)(nil).UntagResource), arg0) +} + +// UntagResourceRequest mocks base method +func (m *MockAthenaAPI) UntagResourceRequest(arg0 *athena.UntagResourceInput) (*request.Request, *athena.UntagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.UntagResourceOutput) + return ret0, ret1 +} + +// UntagResourceRequest indicates an expected call of UntagResourceRequest +func (mr *MockAthenaAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockAthenaAPI)(nil).UntagResourceRequest), arg0) +} + +// UntagResourceWithContext mocks base method +func (m *MockAthenaAPI) UntagResourceWithContext(arg0 context.Context, arg1 *athena.UntagResourceInput, arg2 ...request.Option) (*athena.UntagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) + ret0, _ := ret[0].(*athena.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResourceWithContext indicates an expected call of UntagResourceWithContext +func (mr *MockAthenaAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UntagResourceWithContext), varargs...) +} + +// UpdateDataCatalog mocks base method +func (m *MockAthenaAPI) UpdateDataCatalog(arg0 *athena.UpdateDataCatalogInput) (*athena.UpdateDataCatalogOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateDataCatalog", arg0) + ret0, _ := ret[0].(*athena.UpdateDataCatalogOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateDataCatalog indicates an expected call of UpdateDataCatalog +func (mr *MockAthenaAPIMockRecorder) UpdateDataCatalog(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDataCatalog", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateDataCatalog), arg0) +} + +// UpdateDataCatalogRequest mocks base method +func (m *MockAthenaAPI) UpdateDataCatalogRequest(arg0 *athena.UpdateDataCatalogInput) (*request.Request, *athena.UpdateDataCatalogOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateDataCatalogRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.UpdateDataCatalogOutput) + return ret0, ret1 +} + +// UpdateDataCatalogRequest indicates an expected call of UpdateDataCatalogRequest +func (mr *MockAthenaAPIMockRecorder) UpdateDataCatalogRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDataCatalogRequest", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateDataCatalogRequest), arg0) +} + +// UpdateDataCatalogWithContext mocks base method +func (m *MockAthenaAPI) UpdateDataCatalogWithContext(arg0 context.Context, arg1 *athena.UpdateDataCatalogInput, arg2 ...request.Option) (*athena.UpdateDataCatalogOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateDataCatalogWithContext", varargs...) + ret0, _ := ret[0].(*athena.UpdateDataCatalogOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateDataCatalogWithContext indicates an expected call of UpdateDataCatalogWithContext +func (mr *MockAthenaAPIMockRecorder) UpdateDataCatalogWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDataCatalogWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateDataCatalogWithContext), varargs...) +} + +// UpdateWorkGroup mocks base method +func (m *MockAthenaAPI) UpdateWorkGroup(arg0 *athena.UpdateWorkGroupInput) (*athena.UpdateWorkGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateWorkGroup", arg0) + ret0, _ := ret[0].(*athena.UpdateWorkGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateWorkGroup indicates an expected call of UpdateWorkGroup +func (mr *MockAthenaAPIMockRecorder) UpdateWorkGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkGroup", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateWorkGroup), arg0) +} + +// UpdateWorkGroupRequest mocks base method +func (m *MockAthenaAPI) UpdateWorkGroupRequest(arg0 *athena.UpdateWorkGroupInput) (*request.Request, *athena.UpdateWorkGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateWorkGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*athena.UpdateWorkGroupOutput) + return ret0, ret1 +} + +// UpdateWorkGroupRequest indicates an expected call of UpdateWorkGroupRequest +func (mr *MockAthenaAPIMockRecorder) UpdateWorkGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkGroupRequest", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateWorkGroupRequest), arg0) +} + +// UpdateWorkGroupWithContext mocks base method +func (m *MockAthenaAPI) UpdateWorkGroupWithContext(arg0 context.Context, arg1 *athena.UpdateWorkGroupInput, arg2 ...request.Option) (*athena.UpdateWorkGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateWorkGroupWithContext", varargs...) + ret0, _ := ret[0].(*athena.UpdateWorkGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateWorkGroupWithContext indicates an expected call of UpdateWorkGroupWithContext +func (mr *MockAthenaAPIMockRecorder) UpdateWorkGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkGroupWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateWorkGroupWithContext), varargs...) +} diff --git a/pkg/mocks/mock_aws.go b/pkg/mocks/mock_aws.go new file mode 100644 index 0000000..30bee07 --- /dev/null +++ b/pkg/mocks/mock_aws.go @@ -0,0 +1,368 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/Optum/cloudig/pkg/aws (interfaces: APIs) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + athena "github.com/aws/aws-sdk-go/service/athena" + configservice "github.com/aws/aws-sdk-go/service/configservice" + ec2 "github.com/aws/aws-sdk-go/service/ec2" + ecr "github.com/aws/aws-sdk-go/service/ecr" + health "github.com/aws/aws-sdk-go/service/health" + support "github.com/aws/aws-sdk-go/service/support" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockAPIs is a mock of APIs interface +type MockAPIs struct { + ctrl *gomock.Controller + recorder *MockAPIsMockRecorder +} + +// MockAPIsMockRecorder is the mock recorder for MockAPIs +type MockAPIsMockRecorder struct { + mock *MockAPIs +} + +// NewMockAPIs creates a new mock instance +func NewMockAPIs(ctrl *gomock.Controller) *MockAPIs { + mock := &MockAPIs{ctrl: ctrl} + mock.recorder = &MockAPIsMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockAPIs) EXPECT() *MockAPIsMockRecorder { + return m.recorder +} + +// CreateTableFromMetadata mocks base method +func (m *MockAPIs) CreateTableFromMetadata(arg0 *athena.TableMetadata) (*string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTableFromMetadata", arg0) + ret0, _ := ret[0].(*string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTableFromMetadata indicates an expected call of CreateTableFromMetadata +func (mr *MockAPIsMockRecorder) CreateTableFromMetadata(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTableFromMetadata", reflect.TypeOf((*MockAPIs)(nil).CreateTableFromMetadata), arg0) +} + +// GenerateReport mocks base method +func (m *MockAPIs) GenerateReport(arg0, arg1, arg2 string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateReport", arg0, arg1, arg2) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateReport indicates an expected call of GenerateReport +func (mr *MockAPIsMockRecorder) GenerateReport(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateReport", reflect.TypeOf((*MockAPIs)(nil).GenerateReport), arg0, arg1, arg2) +} + +// GetAccountID mocks base method +func (m *MockAPIs) GetAccountID() (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountID") + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountID indicates an expected call of GetAccountID +func (mr *MockAPIsMockRecorder) GetAccountID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountID", reflect.TypeOf((*MockAPIs)(nil).GetAccountID)) +} + +// GetECRImagesWithTag mocks base method +func (m *MockAPIs) GetECRImagesWithTag(arg0 string) (map[string][]*ecr.ImageDetail, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetECRImagesWithTag", arg0) + ret0, _ := ret[0].(map[string][]*ecr.ImageDetail) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetECRImagesWithTag indicates an expected call of GetECRImagesWithTag +func (mr *MockAPIsMockRecorder) GetECRImagesWithTag(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetECRImagesWithTag", reflect.TypeOf((*MockAPIs)(nil).GetECRImagesWithTag), arg0) +} + +// GetFailingTrustedAdvisorCheckResults mocks base method +func (m *MockAPIs) GetFailingTrustedAdvisorCheckResults() (map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFailingTrustedAdvisorCheckResults") + ret0, _ := ret[0].(map[*support.TrustedAdvisorCheckDescription]*support.TrustedAdvisorCheckResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFailingTrustedAdvisorCheckResults indicates an expected call of GetFailingTrustedAdvisorCheckResults +func (mr *MockAPIsMockRecorder) GetFailingTrustedAdvisorCheckResults() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFailingTrustedAdvisorCheckResults", reflect.TypeOf((*MockAPIs)(nil).GetFailingTrustedAdvisorCheckResults)) +} + +// GetHealthAffectedEntities mocks base method +func (m *MockAPIs) GetHealthAffectedEntities(arg0 []*string, arg1 *string) (*health.DescribeAffectedEntitiesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthAffectedEntities", arg0, arg1) + ret0, _ := ret[0].(*health.DescribeAffectedEntitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthAffectedEntities indicates an expected call of GetHealthAffectedEntities +func (mr *MockAPIsMockRecorder) GetHealthAffectedEntities(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthAffectedEntities", reflect.TypeOf((*MockAPIs)(nil).GetHealthAffectedEntities), arg0, arg1) +} + +// GetHealthEventDetails mocks base method +func (m *MockAPIs) GetHealthEventDetails(arg0 []*string) (*health.DescribeEventDetailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthEventDetails", arg0) + ret0, _ := ret[0].(*health.DescribeEventDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthEventDetails indicates an expected call of GetHealthEventDetails +func (mr *MockAPIsMockRecorder) GetHealthEventDetails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthEventDetails", reflect.TypeOf((*MockAPIs)(nil).GetHealthEventDetails), arg0) +} + +// GetHealthEvents mocks base method +func (m *MockAPIs) GetHealthEvents(arg0 *health.EventFilter, arg1 *string) (*health.DescribeEventsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthEvents", arg0, arg1) + ret0, _ := ret[0].(*health.DescribeEventsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthEvents indicates an expected call of GetHealthEvents +func (mr *MockAPIsMockRecorder) GetHealthEvents(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthEvents", reflect.TypeOf((*MockAPIs)(nil).GetHealthEvents), arg0, arg1) +} + +// GetImageInformation mocks base method +func (m *MockAPIs) GetImageInformation(arg0 []string) (*ec2.DescribeImagesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetImageInformation", arg0) + ret0, _ := ret[0].(*ec2.DescribeImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetImageInformation indicates an expected call of GetImageInformation +func (mr *MockAPIsMockRecorder) GetImageInformation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageInformation", reflect.TypeOf((*MockAPIs)(nil).GetImageInformation), arg0) +} + +// GetInstances mocks base method +func (m *MockAPIs) GetInstances() (*ec2.DescribeInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstances") + ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstances indicates an expected call of GetInstances +func (mr *MockAPIsMockRecorder) GetInstances() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstances", reflect.TypeOf((*MockAPIs)(nil).GetInstances)) +} + +// GetInstancesByFilters mocks base method +func (m *MockAPIs) GetInstancesByFilters(arg0 map[string][]string) (*ec2.DescribeInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstancesByFilters", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstancesByFilters indicates an expected call of GetInstancesByFilters +func (mr *MockAPIsMockRecorder) GetInstancesByFilters(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesByFilters", reflect.TypeOf((*MockAPIs)(nil).GetInstancesByFilters), arg0) +} + +// GetInstancesMatchingAllTags mocks base method +func (m *MockAPIs) GetInstancesMatchingAllTags(arg0 map[string]string) (*ec2.DescribeInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstancesMatchingAllTags", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstancesMatchingAllTags indicates an expected call of GetInstancesMatchingAllTags +func (mr *MockAPIsMockRecorder) GetInstancesMatchingAllTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesMatchingAllTags", reflect.TypeOf((*MockAPIs)(nil).GetInstancesMatchingAllTags), arg0) +} + +// GetInstancesMatchingAnyTags mocks base method +func (m *MockAPIs) GetInstancesMatchingAnyTags(arg0 map[string]string) (*ec2.DescribeInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstancesMatchingAnyTags", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstancesMatchingAnyTags indicates an expected call of GetInstancesMatchingAnyTags +func (mr *MockAPIsMockRecorder) GetInstancesMatchingAnyTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesMatchingAnyTags", reflect.TypeOf((*MockAPIs)(nil).GetInstancesMatchingAnyTags), arg0) +} + +// GetMostRecentAssessmentRunInfo mocks base method +func (m *MockAPIs) GetMostRecentAssessmentRunInfo() ([]map[string]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMostRecentAssessmentRunInfo") + ret0, _ := ret[0].([]map[string]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetMostRecentAssessmentRunInfo indicates an expected call of GetMostRecentAssessmentRunInfo +func (mr *MockAPIsMockRecorder) GetMostRecentAssessmentRunInfo() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMostRecentAssessmentRunInfo", reflect.TypeOf((*MockAPIs)(nil).GetMostRecentAssessmentRunInfo)) +} + +// GetNetIAMPermissionsForRoles mocks base method +func (m *MockAPIs) GetNetIAMPermissionsForRoles(arg0 []string) map[string][]string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNetIAMPermissionsForRoles", arg0) + ret0, _ := ret[0].(map[string][]string) + return ret0 +} + +// GetNetIAMPermissionsForRoles indicates an expected call of GetNetIAMPermissionsForRoles +func (mr *MockAPIsMockRecorder) GetNetIAMPermissionsForRoles(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetIAMPermissionsForRoles", reflect.TypeOf((*MockAPIs)(nil).GetNetIAMPermissionsForRoles), arg0) +} + +// GetNonComplaintConfigRules mocks base method +func (m *MockAPIs) GetNonComplaintConfigRules() (map[string][]*configservice.EvaluationResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNonComplaintConfigRules") + ret0, _ := ret[0].(map[string][]*configservice.EvaluationResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNonComplaintConfigRules indicates an expected call of GetNonComplaintConfigRules +func (mr *MockAPIsMockRecorder) GetNonComplaintConfigRules() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNonComplaintConfigRules", reflect.TypeOf((*MockAPIs)(nil).GetNonComplaintConfigRules)) +} + +// GetResourceGroupTags mocks base method +func (m *MockAPIs) GetResourceGroupTags(arg0 string) (map[string]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResourceGroupTags", arg0) + ret0, _ := ret[0].(map[string]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResourceGroupTags indicates an expected call of GetResourceGroupTags +func (mr *MockAPIsMockRecorder) GetResourceGroupTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceGroupTags", reflect.TypeOf((*MockAPIs)(nil).GetResourceGroupTags), arg0) +} + +// GetRolesFromTags mocks base method +func (m *MockAPIs) GetRolesFromTags(arg0 map[string]string) ([]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRolesFromTags", arg0) + ret0, _ := ret[0].([]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRolesFromTags indicates an expected call of GetRolesFromTags +func (mr *MockAPIsMockRecorder) GetRolesFromTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolesFromTags", reflect.TypeOf((*MockAPIs)(nil).GetRolesFromTags), arg0) +} + +// GetS3LogPrefixForCloudTrail mocks base method +func (m *MockAPIs) GetS3LogPrefixForCloudTrail() (*string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetS3LogPrefixForCloudTrail") + ret0, _ := ret[0].(*string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetS3LogPrefixForCloudTrail indicates an expected call of GetS3LogPrefixForCloudTrail +func (mr *MockAPIsMockRecorder) GetS3LogPrefixForCloudTrail() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetS3LogPrefixForCloudTrail", reflect.TypeOf((*MockAPIs)(nil).GetS3LogPrefixForCloudTrail)) +} + +// GetTableMetadata mocks base method +func (m *MockAPIs) GetTableMetadata(arg0 string) (*athena.TableMetadata, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTableMetadata", arg0) + ret0, _ := ret[0].(*athena.TableMetadata) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTableMetadata indicates an expected call of GetTableMetadata +func (mr *MockAPIsMockRecorder) GetTableMetadata(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTableMetadata", reflect.TypeOf((*MockAPIs)(nil).GetTableMetadata), arg0) +} + +// GetTableforMetadata mocks base method +func (m *MockAPIs) GetTableforMetadata(arg0 *athena.TableMetadata) (*string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTableforMetadata", arg0) + ret0, _ := ret[0].(*string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTableforMetadata indicates an expected call of GetTableforMetadata +func (mr *MockAPIsMockRecorder) GetTableforMetadata(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTableforMetadata", reflect.TypeOf((*MockAPIs)(nil).GetTableforMetadata), arg0) +} + +// RunQuery mocks base method +func (m *MockAPIs) RunQuery(arg0, arg1 string) (*athena.ResultSet, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RunQuery", arg0, arg1) + ret0, _ := ret[0].(*athena.ResultSet) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RunQuery indicates an expected call of RunQuery +func (mr *MockAPIsMockRecorder) RunQuery(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunQuery", reflect.TypeOf((*MockAPIs)(nil).RunQuery), arg0, arg1) +} diff --git a/pkg/mocks/mock_awsconfig.go b/pkg/mocks/mock_awsconfig.go new file mode 100644 index 0000000..a512bcb --- /dev/null +++ b/pkg/mocks/mock_awsconfig.go @@ -0,0 +1,4118 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/configservice/configserviceiface (interfaces: ConfigServiceAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + configservice "github.com/aws/aws-sdk-go/service/configservice" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockConfigServiceAPI is a mock of ConfigServiceAPI interface +type MockConfigServiceAPI struct { + ctrl *gomock.Controller + recorder *MockConfigServiceAPIMockRecorder +} + +// MockConfigServiceAPIMockRecorder is the mock recorder for MockConfigServiceAPI +type MockConfigServiceAPIMockRecorder struct { + mock *MockConfigServiceAPI +} + +// NewMockConfigServiceAPI creates a new mock instance +func NewMockConfigServiceAPI(ctrl *gomock.Controller) *MockConfigServiceAPI { + mock := &MockConfigServiceAPI{ctrl: ctrl} + mock.recorder = &MockConfigServiceAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockConfigServiceAPI) EXPECT() *MockConfigServiceAPIMockRecorder { + return m.recorder +} + +// BatchGetAggregateResourceConfig mocks base method +func (m *MockConfigServiceAPI) BatchGetAggregateResourceConfig(arg0 *configservice.BatchGetAggregateResourceConfigInput) (*configservice.BatchGetAggregateResourceConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetAggregateResourceConfig", arg0) + ret0, _ := ret[0].(*configservice.BatchGetAggregateResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetAggregateResourceConfig indicates an expected call of BatchGetAggregateResourceConfig +func (mr *MockConfigServiceAPIMockRecorder) BatchGetAggregateResourceConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetAggregateResourceConfig", reflect.TypeOf((*MockConfigServiceAPI)(nil).BatchGetAggregateResourceConfig), arg0) +} + +// BatchGetAggregateResourceConfigRequest mocks base method +func (m *MockConfigServiceAPI) BatchGetAggregateResourceConfigRequest(arg0 *configservice.BatchGetAggregateResourceConfigInput) (*request.Request, *configservice.BatchGetAggregateResourceConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetAggregateResourceConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.BatchGetAggregateResourceConfigOutput) + return ret0, ret1 +} + +// BatchGetAggregateResourceConfigRequest indicates an expected call of BatchGetAggregateResourceConfigRequest +func (mr *MockConfigServiceAPIMockRecorder) BatchGetAggregateResourceConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetAggregateResourceConfigRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).BatchGetAggregateResourceConfigRequest), arg0) +} + +// BatchGetAggregateResourceConfigWithContext mocks base method +func (m *MockConfigServiceAPI) BatchGetAggregateResourceConfigWithContext(arg0 context.Context, arg1 *configservice.BatchGetAggregateResourceConfigInput, arg2 ...request.Option) (*configservice.BatchGetAggregateResourceConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchGetAggregateResourceConfigWithContext", varargs...) + ret0, _ := ret[0].(*configservice.BatchGetAggregateResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetAggregateResourceConfigWithContext indicates an expected call of BatchGetAggregateResourceConfigWithContext +func (mr *MockConfigServiceAPIMockRecorder) BatchGetAggregateResourceConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetAggregateResourceConfigWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).BatchGetAggregateResourceConfigWithContext), varargs...) +} + +// BatchGetResourceConfig mocks base method +func (m *MockConfigServiceAPI) BatchGetResourceConfig(arg0 *configservice.BatchGetResourceConfigInput) (*configservice.BatchGetResourceConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetResourceConfig", arg0) + ret0, _ := ret[0].(*configservice.BatchGetResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetResourceConfig indicates an expected call of BatchGetResourceConfig +func (mr *MockConfigServiceAPIMockRecorder) BatchGetResourceConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetResourceConfig", reflect.TypeOf((*MockConfigServiceAPI)(nil).BatchGetResourceConfig), arg0) +} + +// BatchGetResourceConfigRequest mocks base method +func (m *MockConfigServiceAPI) BatchGetResourceConfigRequest(arg0 *configservice.BatchGetResourceConfigInput) (*request.Request, *configservice.BatchGetResourceConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetResourceConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.BatchGetResourceConfigOutput) + return ret0, ret1 +} + +// BatchGetResourceConfigRequest indicates an expected call of BatchGetResourceConfigRequest +func (mr *MockConfigServiceAPIMockRecorder) BatchGetResourceConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetResourceConfigRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).BatchGetResourceConfigRequest), arg0) +} + +// BatchGetResourceConfigWithContext mocks base method +func (m *MockConfigServiceAPI) BatchGetResourceConfigWithContext(arg0 context.Context, arg1 *configservice.BatchGetResourceConfigInput, arg2 ...request.Option) (*configservice.BatchGetResourceConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchGetResourceConfigWithContext", varargs...) + ret0, _ := ret[0].(*configservice.BatchGetResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetResourceConfigWithContext indicates an expected call of BatchGetResourceConfigWithContext +func (mr *MockConfigServiceAPIMockRecorder) BatchGetResourceConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetResourceConfigWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).BatchGetResourceConfigWithContext), varargs...) +} + +// DeleteAggregationAuthorization mocks base method +func (m *MockConfigServiceAPI) DeleteAggregationAuthorization(arg0 *configservice.DeleteAggregationAuthorizationInput) (*configservice.DeleteAggregationAuthorizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAggregationAuthorization", arg0) + ret0, _ := ret[0].(*configservice.DeleteAggregationAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAggregationAuthorization indicates an expected call of DeleteAggregationAuthorization +func (mr *MockConfigServiceAPIMockRecorder) DeleteAggregationAuthorization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAggregationAuthorization", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteAggregationAuthorization), arg0) +} + +// DeleteAggregationAuthorizationRequest mocks base method +func (m *MockConfigServiceAPI) DeleteAggregationAuthorizationRequest(arg0 *configservice.DeleteAggregationAuthorizationInput) (*request.Request, *configservice.DeleteAggregationAuthorizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAggregationAuthorizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteAggregationAuthorizationOutput) + return ret0, ret1 +} + +// DeleteAggregationAuthorizationRequest indicates an expected call of DeleteAggregationAuthorizationRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteAggregationAuthorizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAggregationAuthorizationRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteAggregationAuthorizationRequest), arg0) +} + +// DeleteAggregationAuthorizationWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteAggregationAuthorizationWithContext(arg0 context.Context, arg1 *configservice.DeleteAggregationAuthorizationInput, arg2 ...request.Option) (*configservice.DeleteAggregationAuthorizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAggregationAuthorizationWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteAggregationAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAggregationAuthorizationWithContext indicates an expected call of DeleteAggregationAuthorizationWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteAggregationAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAggregationAuthorizationWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteAggregationAuthorizationWithContext), varargs...) +} + +// DeleteConfigRule mocks base method +func (m *MockConfigServiceAPI) DeleteConfigRule(arg0 *configservice.DeleteConfigRuleInput) (*configservice.DeleteConfigRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConfigRule", arg0) + ret0, _ := ret[0].(*configservice.DeleteConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConfigRule indicates an expected call of DeleteConfigRule +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigRule", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigRule), arg0) +} + +// DeleteConfigRuleRequest mocks base method +func (m *MockConfigServiceAPI) DeleteConfigRuleRequest(arg0 *configservice.DeleteConfigRuleInput) (*request.Request, *configservice.DeleteConfigRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConfigRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteConfigRuleOutput) + return ret0, ret1 +} + +// DeleteConfigRuleRequest indicates an expected call of DeleteConfigRuleRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigRuleRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigRuleRequest), arg0) +} + +// DeleteConfigRuleWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteConfigRuleWithContext(arg0 context.Context, arg1 *configservice.DeleteConfigRuleInput, arg2 ...request.Option) (*configservice.DeleteConfigRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteConfigRuleWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConfigRuleWithContext indicates an expected call of DeleteConfigRuleWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigRuleWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigRuleWithContext), varargs...) +} + +// DeleteConfigurationAggregator mocks base method +func (m *MockConfigServiceAPI) DeleteConfigurationAggregator(arg0 *configservice.DeleteConfigurationAggregatorInput) (*configservice.DeleteConfigurationAggregatorOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConfigurationAggregator", arg0) + ret0, _ := ret[0].(*configservice.DeleteConfigurationAggregatorOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConfigurationAggregator indicates an expected call of DeleteConfigurationAggregator +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigurationAggregator(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationAggregator", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigurationAggregator), arg0) +} + +// DeleteConfigurationAggregatorRequest mocks base method +func (m *MockConfigServiceAPI) DeleteConfigurationAggregatorRequest(arg0 *configservice.DeleteConfigurationAggregatorInput) (*request.Request, *configservice.DeleteConfigurationAggregatorOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConfigurationAggregatorRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteConfigurationAggregatorOutput) + return ret0, ret1 +} + +// DeleteConfigurationAggregatorRequest indicates an expected call of DeleteConfigurationAggregatorRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigurationAggregatorRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationAggregatorRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigurationAggregatorRequest), arg0) +} + +// DeleteConfigurationAggregatorWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteConfigurationAggregatorWithContext(arg0 context.Context, arg1 *configservice.DeleteConfigurationAggregatorInput, arg2 ...request.Option) (*configservice.DeleteConfigurationAggregatorOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteConfigurationAggregatorWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteConfigurationAggregatorOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConfigurationAggregatorWithContext indicates an expected call of DeleteConfigurationAggregatorWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigurationAggregatorWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationAggregatorWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigurationAggregatorWithContext), varargs...) +} + +// DeleteConfigurationRecorder mocks base method +func (m *MockConfigServiceAPI) DeleteConfigurationRecorder(arg0 *configservice.DeleteConfigurationRecorderInput) (*configservice.DeleteConfigurationRecorderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConfigurationRecorder", arg0) + ret0, _ := ret[0].(*configservice.DeleteConfigurationRecorderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConfigurationRecorder indicates an expected call of DeleteConfigurationRecorder +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigurationRecorder(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationRecorder", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigurationRecorder), arg0) +} + +// DeleteConfigurationRecorderRequest mocks base method +func (m *MockConfigServiceAPI) DeleteConfigurationRecorderRequest(arg0 *configservice.DeleteConfigurationRecorderInput) (*request.Request, *configservice.DeleteConfigurationRecorderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConfigurationRecorderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteConfigurationRecorderOutput) + return ret0, ret1 +} + +// DeleteConfigurationRecorderRequest indicates an expected call of DeleteConfigurationRecorderRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigurationRecorderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationRecorderRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigurationRecorderRequest), arg0) +} + +// DeleteConfigurationRecorderWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteConfigurationRecorderWithContext(arg0 context.Context, arg1 *configservice.DeleteConfigurationRecorderInput, arg2 ...request.Option) (*configservice.DeleteConfigurationRecorderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteConfigurationRecorderWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteConfigurationRecorderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConfigurationRecorderWithContext indicates an expected call of DeleteConfigurationRecorderWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteConfigurationRecorderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConfigurationRecorderWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConfigurationRecorderWithContext), varargs...) +} + +// DeleteConformancePack mocks base method +func (m *MockConfigServiceAPI) DeleteConformancePack(arg0 *configservice.DeleteConformancePackInput) (*configservice.DeleteConformancePackOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConformancePack", arg0) + ret0, _ := ret[0].(*configservice.DeleteConformancePackOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConformancePack indicates an expected call of DeleteConformancePack +func (mr *MockConfigServiceAPIMockRecorder) DeleteConformancePack(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConformancePack", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConformancePack), arg0) +} + +// DeleteConformancePackRequest mocks base method +func (m *MockConfigServiceAPI) DeleteConformancePackRequest(arg0 *configservice.DeleteConformancePackInput) (*request.Request, *configservice.DeleteConformancePackOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteConformancePackRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteConformancePackOutput) + return ret0, ret1 +} + +// DeleteConformancePackRequest indicates an expected call of DeleteConformancePackRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteConformancePackRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConformancePackRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConformancePackRequest), arg0) +} + +// DeleteConformancePackWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteConformancePackWithContext(arg0 context.Context, arg1 *configservice.DeleteConformancePackInput, arg2 ...request.Option) (*configservice.DeleteConformancePackOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteConformancePackWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteConformancePackOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteConformancePackWithContext indicates an expected call of DeleteConformancePackWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteConformancePackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConformancePackWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteConformancePackWithContext), varargs...) +} + +// DeleteDeliveryChannel mocks base method +func (m *MockConfigServiceAPI) DeleteDeliveryChannel(arg0 *configservice.DeleteDeliveryChannelInput) (*configservice.DeleteDeliveryChannelOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDeliveryChannel", arg0) + ret0, _ := ret[0].(*configservice.DeleteDeliveryChannelOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDeliveryChannel indicates an expected call of DeleteDeliveryChannel +func (mr *MockConfigServiceAPIMockRecorder) DeleteDeliveryChannel(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeliveryChannel", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteDeliveryChannel), arg0) +} + +// DeleteDeliveryChannelRequest mocks base method +func (m *MockConfigServiceAPI) DeleteDeliveryChannelRequest(arg0 *configservice.DeleteDeliveryChannelInput) (*request.Request, *configservice.DeleteDeliveryChannelOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDeliveryChannelRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteDeliveryChannelOutput) + return ret0, ret1 +} + +// DeleteDeliveryChannelRequest indicates an expected call of DeleteDeliveryChannelRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteDeliveryChannelRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeliveryChannelRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteDeliveryChannelRequest), arg0) +} + +// DeleteDeliveryChannelWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteDeliveryChannelWithContext(arg0 context.Context, arg1 *configservice.DeleteDeliveryChannelInput, arg2 ...request.Option) (*configservice.DeleteDeliveryChannelOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteDeliveryChannelWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteDeliveryChannelOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDeliveryChannelWithContext indicates an expected call of DeleteDeliveryChannelWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteDeliveryChannelWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeliveryChannelWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteDeliveryChannelWithContext), varargs...) +} + +// DeleteEvaluationResults mocks base method +func (m *MockConfigServiceAPI) DeleteEvaluationResults(arg0 *configservice.DeleteEvaluationResultsInput) (*configservice.DeleteEvaluationResultsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteEvaluationResults", arg0) + ret0, _ := ret[0].(*configservice.DeleteEvaluationResultsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteEvaluationResults indicates an expected call of DeleteEvaluationResults +func (mr *MockConfigServiceAPIMockRecorder) DeleteEvaluationResults(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEvaluationResults", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteEvaluationResults), arg0) +} + +// DeleteEvaluationResultsRequest mocks base method +func (m *MockConfigServiceAPI) DeleteEvaluationResultsRequest(arg0 *configservice.DeleteEvaluationResultsInput) (*request.Request, *configservice.DeleteEvaluationResultsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteEvaluationResultsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteEvaluationResultsOutput) + return ret0, ret1 +} + +// DeleteEvaluationResultsRequest indicates an expected call of DeleteEvaluationResultsRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteEvaluationResultsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEvaluationResultsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteEvaluationResultsRequest), arg0) +} + +// DeleteEvaluationResultsWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteEvaluationResultsWithContext(arg0 context.Context, arg1 *configservice.DeleteEvaluationResultsInput, arg2 ...request.Option) (*configservice.DeleteEvaluationResultsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteEvaluationResultsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteEvaluationResultsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteEvaluationResultsWithContext indicates an expected call of DeleteEvaluationResultsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteEvaluationResultsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEvaluationResultsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteEvaluationResultsWithContext), varargs...) +} + +// DeleteOrganizationConfigRule mocks base method +func (m *MockConfigServiceAPI) DeleteOrganizationConfigRule(arg0 *configservice.DeleteOrganizationConfigRuleInput) (*configservice.DeleteOrganizationConfigRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOrganizationConfigRule", arg0) + ret0, _ := ret[0].(*configservice.DeleteOrganizationConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOrganizationConfigRule indicates an expected call of DeleteOrganizationConfigRule +func (mr *MockConfigServiceAPIMockRecorder) DeleteOrganizationConfigRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrganizationConfigRule", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteOrganizationConfigRule), arg0) +} + +// DeleteOrganizationConfigRuleRequest mocks base method +func (m *MockConfigServiceAPI) DeleteOrganizationConfigRuleRequest(arg0 *configservice.DeleteOrganizationConfigRuleInput) (*request.Request, *configservice.DeleteOrganizationConfigRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOrganizationConfigRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteOrganizationConfigRuleOutput) + return ret0, ret1 +} + +// DeleteOrganizationConfigRuleRequest indicates an expected call of DeleteOrganizationConfigRuleRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteOrganizationConfigRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrganizationConfigRuleRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteOrganizationConfigRuleRequest), arg0) +} + +// DeleteOrganizationConfigRuleWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteOrganizationConfigRuleWithContext(arg0 context.Context, arg1 *configservice.DeleteOrganizationConfigRuleInput, arg2 ...request.Option) (*configservice.DeleteOrganizationConfigRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteOrganizationConfigRuleWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteOrganizationConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOrganizationConfigRuleWithContext indicates an expected call of DeleteOrganizationConfigRuleWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteOrganizationConfigRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrganizationConfigRuleWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteOrganizationConfigRuleWithContext), varargs...) +} + +// DeleteOrganizationConformancePack mocks base method +func (m *MockConfigServiceAPI) DeleteOrganizationConformancePack(arg0 *configservice.DeleteOrganizationConformancePackInput) (*configservice.DeleteOrganizationConformancePackOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOrganizationConformancePack", arg0) + ret0, _ := ret[0].(*configservice.DeleteOrganizationConformancePackOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOrganizationConformancePack indicates an expected call of DeleteOrganizationConformancePack +func (mr *MockConfigServiceAPIMockRecorder) DeleteOrganizationConformancePack(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrganizationConformancePack", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteOrganizationConformancePack), arg0) +} + +// DeleteOrganizationConformancePackRequest mocks base method +func (m *MockConfigServiceAPI) DeleteOrganizationConformancePackRequest(arg0 *configservice.DeleteOrganizationConformancePackInput) (*request.Request, *configservice.DeleteOrganizationConformancePackOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOrganizationConformancePackRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteOrganizationConformancePackOutput) + return ret0, ret1 +} + +// DeleteOrganizationConformancePackRequest indicates an expected call of DeleteOrganizationConformancePackRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteOrganizationConformancePackRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrganizationConformancePackRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteOrganizationConformancePackRequest), arg0) +} + +// DeleteOrganizationConformancePackWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteOrganizationConformancePackWithContext(arg0 context.Context, arg1 *configservice.DeleteOrganizationConformancePackInput, arg2 ...request.Option) (*configservice.DeleteOrganizationConformancePackOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteOrganizationConformancePackWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteOrganizationConformancePackOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOrganizationConformancePackWithContext indicates an expected call of DeleteOrganizationConformancePackWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteOrganizationConformancePackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrganizationConformancePackWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteOrganizationConformancePackWithContext), varargs...) +} + +// DeletePendingAggregationRequest mocks base method +func (m *MockConfigServiceAPI) DeletePendingAggregationRequest(arg0 *configservice.DeletePendingAggregationRequestInput) (*configservice.DeletePendingAggregationRequestOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePendingAggregationRequest", arg0) + ret0, _ := ret[0].(*configservice.DeletePendingAggregationRequestOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePendingAggregationRequest indicates an expected call of DeletePendingAggregationRequest +func (mr *MockConfigServiceAPIMockRecorder) DeletePendingAggregationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePendingAggregationRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeletePendingAggregationRequest), arg0) +} + +// DeletePendingAggregationRequestRequest mocks base method +func (m *MockConfigServiceAPI) DeletePendingAggregationRequestRequest(arg0 *configservice.DeletePendingAggregationRequestInput) (*request.Request, *configservice.DeletePendingAggregationRequestOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePendingAggregationRequestRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeletePendingAggregationRequestOutput) + return ret0, ret1 +} + +// DeletePendingAggregationRequestRequest indicates an expected call of DeletePendingAggregationRequestRequest +func (mr *MockConfigServiceAPIMockRecorder) DeletePendingAggregationRequestRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePendingAggregationRequestRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeletePendingAggregationRequestRequest), arg0) +} + +// DeletePendingAggregationRequestWithContext mocks base method +func (m *MockConfigServiceAPI) DeletePendingAggregationRequestWithContext(arg0 context.Context, arg1 *configservice.DeletePendingAggregationRequestInput, arg2 ...request.Option) (*configservice.DeletePendingAggregationRequestOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePendingAggregationRequestWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeletePendingAggregationRequestOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePendingAggregationRequestWithContext indicates an expected call of DeletePendingAggregationRequestWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeletePendingAggregationRequestWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePendingAggregationRequestWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeletePendingAggregationRequestWithContext), varargs...) +} + +// DeleteRemediationConfiguration mocks base method +func (m *MockConfigServiceAPI) DeleteRemediationConfiguration(arg0 *configservice.DeleteRemediationConfigurationInput) (*configservice.DeleteRemediationConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRemediationConfiguration", arg0) + ret0, _ := ret[0].(*configservice.DeleteRemediationConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRemediationConfiguration indicates an expected call of DeleteRemediationConfiguration +func (mr *MockConfigServiceAPIMockRecorder) DeleteRemediationConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRemediationConfiguration", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRemediationConfiguration), arg0) +} + +// DeleteRemediationConfigurationRequest mocks base method +func (m *MockConfigServiceAPI) DeleteRemediationConfigurationRequest(arg0 *configservice.DeleteRemediationConfigurationInput) (*request.Request, *configservice.DeleteRemediationConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRemediationConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteRemediationConfigurationOutput) + return ret0, ret1 +} + +// DeleteRemediationConfigurationRequest indicates an expected call of DeleteRemediationConfigurationRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteRemediationConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRemediationConfigurationRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRemediationConfigurationRequest), arg0) +} + +// DeleteRemediationConfigurationWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteRemediationConfigurationWithContext(arg0 context.Context, arg1 *configservice.DeleteRemediationConfigurationInput, arg2 ...request.Option) (*configservice.DeleteRemediationConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRemediationConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteRemediationConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRemediationConfigurationWithContext indicates an expected call of DeleteRemediationConfigurationWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteRemediationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRemediationConfigurationWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRemediationConfigurationWithContext), varargs...) +} + +// DeleteRemediationExceptions mocks base method +func (m *MockConfigServiceAPI) DeleteRemediationExceptions(arg0 *configservice.DeleteRemediationExceptionsInput) (*configservice.DeleteRemediationExceptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRemediationExceptions", arg0) + ret0, _ := ret[0].(*configservice.DeleteRemediationExceptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRemediationExceptions indicates an expected call of DeleteRemediationExceptions +func (mr *MockConfigServiceAPIMockRecorder) DeleteRemediationExceptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRemediationExceptions", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRemediationExceptions), arg0) +} + +// DeleteRemediationExceptionsRequest mocks base method +func (m *MockConfigServiceAPI) DeleteRemediationExceptionsRequest(arg0 *configservice.DeleteRemediationExceptionsInput) (*request.Request, *configservice.DeleteRemediationExceptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRemediationExceptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteRemediationExceptionsOutput) + return ret0, ret1 +} + +// DeleteRemediationExceptionsRequest indicates an expected call of DeleteRemediationExceptionsRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteRemediationExceptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRemediationExceptionsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRemediationExceptionsRequest), arg0) +} + +// DeleteRemediationExceptionsWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteRemediationExceptionsWithContext(arg0 context.Context, arg1 *configservice.DeleteRemediationExceptionsInput, arg2 ...request.Option) (*configservice.DeleteRemediationExceptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRemediationExceptionsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteRemediationExceptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRemediationExceptionsWithContext indicates an expected call of DeleteRemediationExceptionsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteRemediationExceptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRemediationExceptionsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRemediationExceptionsWithContext), varargs...) +} + +// DeleteResourceConfig mocks base method +func (m *MockConfigServiceAPI) DeleteResourceConfig(arg0 *configservice.DeleteResourceConfigInput) (*configservice.DeleteResourceConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteResourceConfig", arg0) + ret0, _ := ret[0].(*configservice.DeleteResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteResourceConfig indicates an expected call of DeleteResourceConfig +func (mr *MockConfigServiceAPIMockRecorder) DeleteResourceConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceConfig", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteResourceConfig), arg0) +} + +// DeleteResourceConfigRequest mocks base method +func (m *MockConfigServiceAPI) DeleteResourceConfigRequest(arg0 *configservice.DeleteResourceConfigInput) (*request.Request, *configservice.DeleteResourceConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteResourceConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteResourceConfigOutput) + return ret0, ret1 +} + +// DeleteResourceConfigRequest indicates an expected call of DeleteResourceConfigRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteResourceConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceConfigRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteResourceConfigRequest), arg0) +} + +// DeleteResourceConfigWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteResourceConfigWithContext(arg0 context.Context, arg1 *configservice.DeleteResourceConfigInput, arg2 ...request.Option) (*configservice.DeleteResourceConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteResourceConfigWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteResourceConfigWithContext indicates an expected call of DeleteResourceConfigWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteResourceConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceConfigWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteResourceConfigWithContext), varargs...) +} + +// DeleteRetentionConfiguration mocks base method +func (m *MockConfigServiceAPI) DeleteRetentionConfiguration(arg0 *configservice.DeleteRetentionConfigurationInput) (*configservice.DeleteRetentionConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRetentionConfiguration", arg0) + ret0, _ := ret[0].(*configservice.DeleteRetentionConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRetentionConfiguration indicates an expected call of DeleteRetentionConfiguration +func (mr *MockConfigServiceAPIMockRecorder) DeleteRetentionConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRetentionConfiguration", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRetentionConfiguration), arg0) +} + +// DeleteRetentionConfigurationRequest mocks base method +func (m *MockConfigServiceAPI) DeleteRetentionConfigurationRequest(arg0 *configservice.DeleteRetentionConfigurationInput) (*request.Request, *configservice.DeleteRetentionConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRetentionConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeleteRetentionConfigurationOutput) + return ret0, ret1 +} + +// DeleteRetentionConfigurationRequest indicates an expected call of DeleteRetentionConfigurationRequest +func (mr *MockConfigServiceAPIMockRecorder) DeleteRetentionConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRetentionConfigurationRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRetentionConfigurationRequest), arg0) +} + +// DeleteRetentionConfigurationWithContext mocks base method +func (m *MockConfigServiceAPI) DeleteRetentionConfigurationWithContext(arg0 context.Context, arg1 *configservice.DeleteRetentionConfigurationInput, arg2 ...request.Option) (*configservice.DeleteRetentionConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRetentionConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeleteRetentionConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRetentionConfigurationWithContext indicates an expected call of DeleteRetentionConfigurationWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeleteRetentionConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRetentionConfigurationWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeleteRetentionConfigurationWithContext), varargs...) +} + +// DeliverConfigSnapshot mocks base method +func (m *MockConfigServiceAPI) DeliverConfigSnapshot(arg0 *configservice.DeliverConfigSnapshotInput) (*configservice.DeliverConfigSnapshotOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeliverConfigSnapshot", arg0) + ret0, _ := ret[0].(*configservice.DeliverConfigSnapshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeliverConfigSnapshot indicates an expected call of DeliverConfigSnapshot +func (mr *MockConfigServiceAPIMockRecorder) DeliverConfigSnapshot(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeliverConfigSnapshot", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeliverConfigSnapshot), arg0) +} + +// DeliverConfigSnapshotRequest mocks base method +func (m *MockConfigServiceAPI) DeliverConfigSnapshotRequest(arg0 *configservice.DeliverConfigSnapshotInput) (*request.Request, *configservice.DeliverConfigSnapshotOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeliverConfigSnapshotRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DeliverConfigSnapshotOutput) + return ret0, ret1 +} + +// DeliverConfigSnapshotRequest indicates an expected call of DeliverConfigSnapshotRequest +func (mr *MockConfigServiceAPIMockRecorder) DeliverConfigSnapshotRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeliverConfigSnapshotRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeliverConfigSnapshotRequest), arg0) +} + +// DeliverConfigSnapshotWithContext mocks base method +func (m *MockConfigServiceAPI) DeliverConfigSnapshotWithContext(arg0 context.Context, arg1 *configservice.DeliverConfigSnapshotInput, arg2 ...request.Option) (*configservice.DeliverConfigSnapshotOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeliverConfigSnapshotWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DeliverConfigSnapshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeliverConfigSnapshotWithContext indicates an expected call of DeliverConfigSnapshotWithContext +func (mr *MockConfigServiceAPIMockRecorder) DeliverConfigSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeliverConfigSnapshotWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DeliverConfigSnapshotWithContext), varargs...) +} + +// DescribeAggregateComplianceByConfigRules mocks base method +func (m *MockConfigServiceAPI) DescribeAggregateComplianceByConfigRules(arg0 *configservice.DescribeAggregateComplianceByConfigRulesInput) (*configservice.DescribeAggregateComplianceByConfigRulesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAggregateComplianceByConfigRules", arg0) + ret0, _ := ret[0].(*configservice.DescribeAggregateComplianceByConfigRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAggregateComplianceByConfigRules indicates an expected call of DescribeAggregateComplianceByConfigRules +func (mr *MockConfigServiceAPIMockRecorder) DescribeAggregateComplianceByConfigRules(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateComplianceByConfigRules", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeAggregateComplianceByConfigRules), arg0) +} + +// DescribeAggregateComplianceByConfigRulesRequest mocks base method +func (m *MockConfigServiceAPI) DescribeAggregateComplianceByConfigRulesRequest(arg0 *configservice.DescribeAggregateComplianceByConfigRulesInput) (*request.Request, *configservice.DescribeAggregateComplianceByConfigRulesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAggregateComplianceByConfigRulesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeAggregateComplianceByConfigRulesOutput) + return ret0, ret1 +} + +// DescribeAggregateComplianceByConfigRulesRequest indicates an expected call of DescribeAggregateComplianceByConfigRulesRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeAggregateComplianceByConfigRulesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateComplianceByConfigRulesRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeAggregateComplianceByConfigRulesRequest), arg0) +} + +// DescribeAggregateComplianceByConfigRulesWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeAggregateComplianceByConfigRulesWithContext(arg0 context.Context, arg1 *configservice.DescribeAggregateComplianceByConfigRulesInput, arg2 ...request.Option) (*configservice.DescribeAggregateComplianceByConfigRulesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAggregateComplianceByConfigRulesWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeAggregateComplianceByConfigRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAggregateComplianceByConfigRulesWithContext indicates an expected call of DescribeAggregateComplianceByConfigRulesWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeAggregateComplianceByConfigRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateComplianceByConfigRulesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeAggregateComplianceByConfigRulesWithContext), varargs...) +} + +// DescribeAggregationAuthorizations mocks base method +func (m *MockConfigServiceAPI) DescribeAggregationAuthorizations(arg0 *configservice.DescribeAggregationAuthorizationsInput) (*configservice.DescribeAggregationAuthorizationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAggregationAuthorizations", arg0) + ret0, _ := ret[0].(*configservice.DescribeAggregationAuthorizationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAggregationAuthorizations indicates an expected call of DescribeAggregationAuthorizations +func (mr *MockConfigServiceAPIMockRecorder) DescribeAggregationAuthorizations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregationAuthorizations", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeAggregationAuthorizations), arg0) +} + +// DescribeAggregationAuthorizationsRequest mocks base method +func (m *MockConfigServiceAPI) DescribeAggregationAuthorizationsRequest(arg0 *configservice.DescribeAggregationAuthorizationsInput) (*request.Request, *configservice.DescribeAggregationAuthorizationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAggregationAuthorizationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeAggregationAuthorizationsOutput) + return ret0, ret1 +} + +// DescribeAggregationAuthorizationsRequest indicates an expected call of DescribeAggregationAuthorizationsRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeAggregationAuthorizationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregationAuthorizationsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeAggregationAuthorizationsRequest), arg0) +} + +// DescribeAggregationAuthorizationsWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeAggregationAuthorizationsWithContext(arg0 context.Context, arg1 *configservice.DescribeAggregationAuthorizationsInput, arg2 ...request.Option) (*configservice.DescribeAggregationAuthorizationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAggregationAuthorizationsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeAggregationAuthorizationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAggregationAuthorizationsWithContext indicates an expected call of DescribeAggregationAuthorizationsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeAggregationAuthorizationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregationAuthorizationsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeAggregationAuthorizationsWithContext), varargs...) +} + +// DescribeComplianceByConfigRule mocks base method +func (m *MockConfigServiceAPI) DescribeComplianceByConfigRule(arg0 *configservice.DescribeComplianceByConfigRuleInput) (*configservice.DescribeComplianceByConfigRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeComplianceByConfigRule", arg0) + ret0, _ := ret[0].(*configservice.DescribeComplianceByConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeComplianceByConfigRule indicates an expected call of DescribeComplianceByConfigRule +func (mr *MockConfigServiceAPIMockRecorder) DescribeComplianceByConfigRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeComplianceByConfigRule", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeComplianceByConfigRule), arg0) +} + +// DescribeComplianceByConfigRuleRequest mocks base method +func (m *MockConfigServiceAPI) DescribeComplianceByConfigRuleRequest(arg0 *configservice.DescribeComplianceByConfigRuleInput) (*request.Request, *configservice.DescribeComplianceByConfigRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeComplianceByConfigRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeComplianceByConfigRuleOutput) + return ret0, ret1 +} + +// DescribeComplianceByConfigRuleRequest indicates an expected call of DescribeComplianceByConfigRuleRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeComplianceByConfigRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeComplianceByConfigRuleRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeComplianceByConfigRuleRequest), arg0) +} + +// DescribeComplianceByConfigRuleWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeComplianceByConfigRuleWithContext(arg0 context.Context, arg1 *configservice.DescribeComplianceByConfigRuleInput, arg2 ...request.Option) (*configservice.DescribeComplianceByConfigRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeComplianceByConfigRuleWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeComplianceByConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeComplianceByConfigRuleWithContext indicates an expected call of DescribeComplianceByConfigRuleWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeComplianceByConfigRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeComplianceByConfigRuleWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeComplianceByConfigRuleWithContext), varargs...) +} + +// DescribeComplianceByResource mocks base method +func (m *MockConfigServiceAPI) DescribeComplianceByResource(arg0 *configservice.DescribeComplianceByResourceInput) (*configservice.DescribeComplianceByResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeComplianceByResource", arg0) + ret0, _ := ret[0].(*configservice.DescribeComplianceByResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeComplianceByResource indicates an expected call of DescribeComplianceByResource +func (mr *MockConfigServiceAPIMockRecorder) DescribeComplianceByResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeComplianceByResource", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeComplianceByResource), arg0) +} + +// DescribeComplianceByResourceRequest mocks base method +func (m *MockConfigServiceAPI) DescribeComplianceByResourceRequest(arg0 *configservice.DescribeComplianceByResourceInput) (*request.Request, *configservice.DescribeComplianceByResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeComplianceByResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeComplianceByResourceOutput) + return ret0, ret1 +} + +// DescribeComplianceByResourceRequest indicates an expected call of DescribeComplianceByResourceRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeComplianceByResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeComplianceByResourceRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeComplianceByResourceRequest), arg0) +} + +// DescribeComplianceByResourceWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeComplianceByResourceWithContext(arg0 context.Context, arg1 *configservice.DescribeComplianceByResourceInput, arg2 ...request.Option) (*configservice.DescribeComplianceByResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeComplianceByResourceWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeComplianceByResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeComplianceByResourceWithContext indicates an expected call of DescribeComplianceByResourceWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeComplianceByResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeComplianceByResourceWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeComplianceByResourceWithContext), varargs...) +} + +// DescribeConfigRuleEvaluationStatus mocks base method +func (m *MockConfigServiceAPI) DescribeConfigRuleEvaluationStatus(arg0 *configservice.DescribeConfigRuleEvaluationStatusInput) (*configservice.DescribeConfigRuleEvaluationStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigRuleEvaluationStatus", arg0) + ret0, _ := ret[0].(*configservice.DescribeConfigRuleEvaluationStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigRuleEvaluationStatus indicates an expected call of DescribeConfigRuleEvaluationStatus +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigRuleEvaluationStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigRuleEvaluationStatus", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigRuleEvaluationStatus), arg0) +} + +// DescribeConfigRuleEvaluationStatusRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConfigRuleEvaluationStatusRequest(arg0 *configservice.DescribeConfigRuleEvaluationStatusInput) (*request.Request, *configservice.DescribeConfigRuleEvaluationStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigRuleEvaluationStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConfigRuleEvaluationStatusOutput) + return ret0, ret1 +} + +// DescribeConfigRuleEvaluationStatusRequest indicates an expected call of DescribeConfigRuleEvaluationStatusRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigRuleEvaluationStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigRuleEvaluationStatusRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigRuleEvaluationStatusRequest), arg0) +} + +// DescribeConfigRuleEvaluationStatusWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConfigRuleEvaluationStatusWithContext(arg0 context.Context, arg1 *configservice.DescribeConfigRuleEvaluationStatusInput, arg2 ...request.Option) (*configservice.DescribeConfigRuleEvaluationStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConfigRuleEvaluationStatusWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConfigRuleEvaluationStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigRuleEvaluationStatusWithContext indicates an expected call of DescribeConfigRuleEvaluationStatusWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigRuleEvaluationStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigRuleEvaluationStatusWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigRuleEvaluationStatusWithContext), varargs...) +} + +// DescribeConfigRules mocks base method +func (m *MockConfigServiceAPI) DescribeConfigRules(arg0 *configservice.DescribeConfigRulesInput) (*configservice.DescribeConfigRulesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigRules", arg0) + ret0, _ := ret[0].(*configservice.DescribeConfigRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigRules indicates an expected call of DescribeConfigRules +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigRules(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigRules", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigRules), arg0) +} + +// DescribeConfigRulesRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConfigRulesRequest(arg0 *configservice.DescribeConfigRulesInput) (*request.Request, *configservice.DescribeConfigRulesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigRulesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConfigRulesOutput) + return ret0, ret1 +} + +// DescribeConfigRulesRequest indicates an expected call of DescribeConfigRulesRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigRulesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigRulesRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigRulesRequest), arg0) +} + +// DescribeConfigRulesWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConfigRulesWithContext(arg0 context.Context, arg1 *configservice.DescribeConfigRulesInput, arg2 ...request.Option) (*configservice.DescribeConfigRulesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConfigRulesWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConfigRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigRulesWithContext indicates an expected call of DescribeConfigRulesWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigRulesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigRulesWithContext), varargs...) +} + +// DescribeConfigurationAggregatorSourcesStatus mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationAggregatorSourcesStatus(arg0 *configservice.DescribeConfigurationAggregatorSourcesStatusInput) (*configservice.DescribeConfigurationAggregatorSourcesStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationAggregatorSourcesStatus", arg0) + ret0, _ := ret[0].(*configservice.DescribeConfigurationAggregatorSourcesStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationAggregatorSourcesStatus indicates an expected call of DescribeConfigurationAggregatorSourcesStatus +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationAggregatorSourcesStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationAggregatorSourcesStatus", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationAggregatorSourcesStatus), arg0) +} + +// DescribeConfigurationAggregatorSourcesStatusRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationAggregatorSourcesStatusRequest(arg0 *configservice.DescribeConfigurationAggregatorSourcesStatusInput) (*request.Request, *configservice.DescribeConfigurationAggregatorSourcesStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationAggregatorSourcesStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConfigurationAggregatorSourcesStatusOutput) + return ret0, ret1 +} + +// DescribeConfigurationAggregatorSourcesStatusRequest indicates an expected call of DescribeConfigurationAggregatorSourcesStatusRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationAggregatorSourcesStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationAggregatorSourcesStatusRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationAggregatorSourcesStatusRequest), arg0) +} + +// DescribeConfigurationAggregatorSourcesStatusWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationAggregatorSourcesStatusWithContext(arg0 context.Context, arg1 *configservice.DescribeConfigurationAggregatorSourcesStatusInput, arg2 ...request.Option) (*configservice.DescribeConfigurationAggregatorSourcesStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConfigurationAggregatorSourcesStatusWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConfigurationAggregatorSourcesStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationAggregatorSourcesStatusWithContext indicates an expected call of DescribeConfigurationAggregatorSourcesStatusWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationAggregatorSourcesStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationAggregatorSourcesStatusWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationAggregatorSourcesStatusWithContext), varargs...) +} + +// DescribeConfigurationAggregators mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationAggregators(arg0 *configservice.DescribeConfigurationAggregatorsInput) (*configservice.DescribeConfigurationAggregatorsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationAggregators", arg0) + ret0, _ := ret[0].(*configservice.DescribeConfigurationAggregatorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationAggregators indicates an expected call of DescribeConfigurationAggregators +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationAggregators(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationAggregators", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationAggregators), arg0) +} + +// DescribeConfigurationAggregatorsRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationAggregatorsRequest(arg0 *configservice.DescribeConfigurationAggregatorsInput) (*request.Request, *configservice.DescribeConfigurationAggregatorsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationAggregatorsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConfigurationAggregatorsOutput) + return ret0, ret1 +} + +// DescribeConfigurationAggregatorsRequest indicates an expected call of DescribeConfigurationAggregatorsRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationAggregatorsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationAggregatorsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationAggregatorsRequest), arg0) +} + +// DescribeConfigurationAggregatorsWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationAggregatorsWithContext(arg0 context.Context, arg1 *configservice.DescribeConfigurationAggregatorsInput, arg2 ...request.Option) (*configservice.DescribeConfigurationAggregatorsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConfigurationAggregatorsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConfigurationAggregatorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationAggregatorsWithContext indicates an expected call of DescribeConfigurationAggregatorsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationAggregatorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationAggregatorsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationAggregatorsWithContext), varargs...) +} + +// DescribeConfigurationRecorderStatus mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationRecorderStatus(arg0 *configservice.DescribeConfigurationRecorderStatusInput) (*configservice.DescribeConfigurationRecorderStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationRecorderStatus", arg0) + ret0, _ := ret[0].(*configservice.DescribeConfigurationRecorderStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationRecorderStatus indicates an expected call of DescribeConfigurationRecorderStatus +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationRecorderStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationRecorderStatus", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationRecorderStatus), arg0) +} + +// DescribeConfigurationRecorderStatusRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationRecorderStatusRequest(arg0 *configservice.DescribeConfigurationRecorderStatusInput) (*request.Request, *configservice.DescribeConfigurationRecorderStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationRecorderStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConfigurationRecorderStatusOutput) + return ret0, ret1 +} + +// DescribeConfigurationRecorderStatusRequest indicates an expected call of DescribeConfigurationRecorderStatusRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationRecorderStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationRecorderStatusRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationRecorderStatusRequest), arg0) +} + +// DescribeConfigurationRecorderStatusWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationRecorderStatusWithContext(arg0 context.Context, arg1 *configservice.DescribeConfigurationRecorderStatusInput, arg2 ...request.Option) (*configservice.DescribeConfigurationRecorderStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConfigurationRecorderStatusWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConfigurationRecorderStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationRecorderStatusWithContext indicates an expected call of DescribeConfigurationRecorderStatusWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationRecorderStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationRecorderStatusWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationRecorderStatusWithContext), varargs...) +} + +// DescribeConfigurationRecorders mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationRecorders(arg0 *configservice.DescribeConfigurationRecordersInput) (*configservice.DescribeConfigurationRecordersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationRecorders", arg0) + ret0, _ := ret[0].(*configservice.DescribeConfigurationRecordersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationRecorders indicates an expected call of DescribeConfigurationRecorders +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationRecorders(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationRecorders", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationRecorders), arg0) +} + +// DescribeConfigurationRecordersRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationRecordersRequest(arg0 *configservice.DescribeConfigurationRecordersInput) (*request.Request, *configservice.DescribeConfigurationRecordersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConfigurationRecordersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConfigurationRecordersOutput) + return ret0, ret1 +} + +// DescribeConfigurationRecordersRequest indicates an expected call of DescribeConfigurationRecordersRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationRecordersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationRecordersRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationRecordersRequest), arg0) +} + +// DescribeConfigurationRecordersWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConfigurationRecordersWithContext(arg0 context.Context, arg1 *configservice.DescribeConfigurationRecordersInput, arg2 ...request.Option) (*configservice.DescribeConfigurationRecordersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConfigurationRecordersWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConfigurationRecordersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConfigurationRecordersWithContext indicates an expected call of DescribeConfigurationRecordersWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConfigurationRecordersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfigurationRecordersWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConfigurationRecordersWithContext), varargs...) +} + +// DescribeConformancePackCompliance mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePackCompliance(arg0 *configservice.DescribeConformancePackComplianceInput) (*configservice.DescribeConformancePackComplianceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConformancePackCompliance", arg0) + ret0, _ := ret[0].(*configservice.DescribeConformancePackComplianceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConformancePackCompliance indicates an expected call of DescribeConformancePackCompliance +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePackCompliance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePackCompliance", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePackCompliance), arg0) +} + +// DescribeConformancePackComplianceRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePackComplianceRequest(arg0 *configservice.DescribeConformancePackComplianceInput) (*request.Request, *configservice.DescribeConformancePackComplianceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConformancePackComplianceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConformancePackComplianceOutput) + return ret0, ret1 +} + +// DescribeConformancePackComplianceRequest indicates an expected call of DescribeConformancePackComplianceRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePackComplianceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePackComplianceRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePackComplianceRequest), arg0) +} + +// DescribeConformancePackComplianceWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePackComplianceWithContext(arg0 context.Context, arg1 *configservice.DescribeConformancePackComplianceInput, arg2 ...request.Option) (*configservice.DescribeConformancePackComplianceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConformancePackComplianceWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConformancePackComplianceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConformancePackComplianceWithContext indicates an expected call of DescribeConformancePackComplianceWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePackComplianceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePackComplianceWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePackComplianceWithContext), varargs...) +} + +// DescribeConformancePackStatus mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePackStatus(arg0 *configservice.DescribeConformancePackStatusInput) (*configservice.DescribeConformancePackStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConformancePackStatus", arg0) + ret0, _ := ret[0].(*configservice.DescribeConformancePackStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConformancePackStatus indicates an expected call of DescribeConformancePackStatus +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePackStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePackStatus", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePackStatus), arg0) +} + +// DescribeConformancePackStatusRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePackStatusRequest(arg0 *configservice.DescribeConformancePackStatusInput) (*request.Request, *configservice.DescribeConformancePackStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConformancePackStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConformancePackStatusOutput) + return ret0, ret1 +} + +// DescribeConformancePackStatusRequest indicates an expected call of DescribeConformancePackStatusRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePackStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePackStatusRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePackStatusRequest), arg0) +} + +// DescribeConformancePackStatusWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePackStatusWithContext(arg0 context.Context, arg1 *configservice.DescribeConformancePackStatusInput, arg2 ...request.Option) (*configservice.DescribeConformancePackStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConformancePackStatusWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConformancePackStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConformancePackStatusWithContext indicates an expected call of DescribeConformancePackStatusWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePackStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePackStatusWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePackStatusWithContext), varargs...) +} + +// DescribeConformancePacks mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePacks(arg0 *configservice.DescribeConformancePacksInput) (*configservice.DescribeConformancePacksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConformancePacks", arg0) + ret0, _ := ret[0].(*configservice.DescribeConformancePacksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConformancePacks indicates an expected call of DescribeConformancePacks +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePacks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePacks", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePacks), arg0) +} + +// DescribeConformancePacksRequest mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePacksRequest(arg0 *configservice.DescribeConformancePacksInput) (*request.Request, *configservice.DescribeConformancePacksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConformancePacksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeConformancePacksOutput) + return ret0, ret1 +} + +// DescribeConformancePacksRequest indicates an expected call of DescribeConformancePacksRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePacksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePacksRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePacksRequest), arg0) +} + +// DescribeConformancePacksWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeConformancePacksWithContext(arg0 context.Context, arg1 *configservice.DescribeConformancePacksInput, arg2 ...request.Option) (*configservice.DescribeConformancePacksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConformancePacksWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeConformancePacksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConformancePacksWithContext indicates an expected call of DescribeConformancePacksWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeConformancePacksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConformancePacksWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeConformancePacksWithContext), varargs...) +} + +// DescribeDeliveryChannelStatus mocks base method +func (m *MockConfigServiceAPI) DescribeDeliveryChannelStatus(arg0 *configservice.DescribeDeliveryChannelStatusInput) (*configservice.DescribeDeliveryChannelStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeDeliveryChannelStatus", arg0) + ret0, _ := ret[0].(*configservice.DescribeDeliveryChannelStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeDeliveryChannelStatus indicates an expected call of DescribeDeliveryChannelStatus +func (mr *MockConfigServiceAPIMockRecorder) DescribeDeliveryChannelStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDeliveryChannelStatus", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeDeliveryChannelStatus), arg0) +} + +// DescribeDeliveryChannelStatusRequest mocks base method +func (m *MockConfigServiceAPI) DescribeDeliveryChannelStatusRequest(arg0 *configservice.DescribeDeliveryChannelStatusInput) (*request.Request, *configservice.DescribeDeliveryChannelStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeDeliveryChannelStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeDeliveryChannelStatusOutput) + return ret0, ret1 +} + +// DescribeDeliveryChannelStatusRequest indicates an expected call of DescribeDeliveryChannelStatusRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeDeliveryChannelStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDeliveryChannelStatusRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeDeliveryChannelStatusRequest), arg0) +} + +// DescribeDeliveryChannelStatusWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeDeliveryChannelStatusWithContext(arg0 context.Context, arg1 *configservice.DescribeDeliveryChannelStatusInput, arg2 ...request.Option) (*configservice.DescribeDeliveryChannelStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeDeliveryChannelStatusWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeDeliveryChannelStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeDeliveryChannelStatusWithContext indicates an expected call of DescribeDeliveryChannelStatusWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeDeliveryChannelStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDeliveryChannelStatusWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeDeliveryChannelStatusWithContext), varargs...) +} + +// DescribeDeliveryChannels mocks base method +func (m *MockConfigServiceAPI) DescribeDeliveryChannels(arg0 *configservice.DescribeDeliveryChannelsInput) (*configservice.DescribeDeliveryChannelsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeDeliveryChannels", arg0) + ret0, _ := ret[0].(*configservice.DescribeDeliveryChannelsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeDeliveryChannels indicates an expected call of DescribeDeliveryChannels +func (mr *MockConfigServiceAPIMockRecorder) DescribeDeliveryChannels(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDeliveryChannels", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeDeliveryChannels), arg0) +} + +// DescribeDeliveryChannelsRequest mocks base method +func (m *MockConfigServiceAPI) DescribeDeliveryChannelsRequest(arg0 *configservice.DescribeDeliveryChannelsInput) (*request.Request, *configservice.DescribeDeliveryChannelsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeDeliveryChannelsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeDeliveryChannelsOutput) + return ret0, ret1 +} + +// DescribeDeliveryChannelsRequest indicates an expected call of DescribeDeliveryChannelsRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeDeliveryChannelsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDeliveryChannelsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeDeliveryChannelsRequest), arg0) +} + +// DescribeDeliveryChannelsWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeDeliveryChannelsWithContext(arg0 context.Context, arg1 *configservice.DescribeDeliveryChannelsInput, arg2 ...request.Option) (*configservice.DescribeDeliveryChannelsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeDeliveryChannelsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeDeliveryChannelsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeDeliveryChannelsWithContext indicates an expected call of DescribeDeliveryChannelsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeDeliveryChannelsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDeliveryChannelsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeDeliveryChannelsWithContext), varargs...) +} + +// DescribeOrganizationConfigRuleStatuses mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConfigRuleStatuses(arg0 *configservice.DescribeOrganizationConfigRuleStatusesInput) (*configservice.DescribeOrganizationConfigRuleStatusesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOrganizationConfigRuleStatuses", arg0) + ret0, _ := ret[0].(*configservice.DescribeOrganizationConfigRuleStatusesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOrganizationConfigRuleStatuses indicates an expected call of DescribeOrganizationConfigRuleStatuses +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConfigRuleStatuses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConfigRuleStatuses", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConfigRuleStatuses), arg0) +} + +// DescribeOrganizationConfigRuleStatusesRequest mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConfigRuleStatusesRequest(arg0 *configservice.DescribeOrganizationConfigRuleStatusesInput) (*request.Request, *configservice.DescribeOrganizationConfigRuleStatusesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOrganizationConfigRuleStatusesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeOrganizationConfigRuleStatusesOutput) + return ret0, ret1 +} + +// DescribeOrganizationConfigRuleStatusesRequest indicates an expected call of DescribeOrganizationConfigRuleStatusesRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConfigRuleStatusesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConfigRuleStatusesRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConfigRuleStatusesRequest), arg0) +} + +// DescribeOrganizationConfigRuleStatusesWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConfigRuleStatusesWithContext(arg0 context.Context, arg1 *configservice.DescribeOrganizationConfigRuleStatusesInput, arg2 ...request.Option) (*configservice.DescribeOrganizationConfigRuleStatusesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeOrganizationConfigRuleStatusesWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeOrganizationConfigRuleStatusesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOrganizationConfigRuleStatusesWithContext indicates an expected call of DescribeOrganizationConfigRuleStatusesWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConfigRuleStatusesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConfigRuleStatusesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConfigRuleStatusesWithContext), varargs...) +} + +// DescribeOrganizationConfigRules mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConfigRules(arg0 *configservice.DescribeOrganizationConfigRulesInput) (*configservice.DescribeOrganizationConfigRulesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOrganizationConfigRules", arg0) + ret0, _ := ret[0].(*configservice.DescribeOrganizationConfigRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOrganizationConfigRules indicates an expected call of DescribeOrganizationConfigRules +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConfigRules(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConfigRules", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConfigRules), arg0) +} + +// DescribeOrganizationConfigRulesRequest mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConfigRulesRequest(arg0 *configservice.DescribeOrganizationConfigRulesInput) (*request.Request, *configservice.DescribeOrganizationConfigRulesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOrganizationConfigRulesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeOrganizationConfigRulesOutput) + return ret0, ret1 +} + +// DescribeOrganizationConfigRulesRequest indicates an expected call of DescribeOrganizationConfigRulesRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConfigRulesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConfigRulesRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConfigRulesRequest), arg0) +} + +// DescribeOrganizationConfigRulesWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConfigRulesWithContext(arg0 context.Context, arg1 *configservice.DescribeOrganizationConfigRulesInput, arg2 ...request.Option) (*configservice.DescribeOrganizationConfigRulesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeOrganizationConfigRulesWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeOrganizationConfigRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOrganizationConfigRulesWithContext indicates an expected call of DescribeOrganizationConfigRulesWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConfigRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConfigRulesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConfigRulesWithContext), varargs...) +} + +// DescribeOrganizationConformancePackStatuses mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConformancePackStatuses(arg0 *configservice.DescribeOrganizationConformancePackStatusesInput) (*configservice.DescribeOrganizationConformancePackStatusesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOrganizationConformancePackStatuses", arg0) + ret0, _ := ret[0].(*configservice.DescribeOrganizationConformancePackStatusesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOrganizationConformancePackStatuses indicates an expected call of DescribeOrganizationConformancePackStatuses +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConformancePackStatuses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConformancePackStatuses", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConformancePackStatuses), arg0) +} + +// DescribeOrganizationConformancePackStatusesRequest mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConformancePackStatusesRequest(arg0 *configservice.DescribeOrganizationConformancePackStatusesInput) (*request.Request, *configservice.DescribeOrganizationConformancePackStatusesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOrganizationConformancePackStatusesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeOrganizationConformancePackStatusesOutput) + return ret0, ret1 +} + +// DescribeOrganizationConformancePackStatusesRequest indicates an expected call of DescribeOrganizationConformancePackStatusesRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConformancePackStatusesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConformancePackStatusesRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConformancePackStatusesRequest), arg0) +} + +// DescribeOrganizationConformancePackStatusesWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConformancePackStatusesWithContext(arg0 context.Context, arg1 *configservice.DescribeOrganizationConformancePackStatusesInput, arg2 ...request.Option) (*configservice.DescribeOrganizationConformancePackStatusesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeOrganizationConformancePackStatusesWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeOrganizationConformancePackStatusesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOrganizationConformancePackStatusesWithContext indicates an expected call of DescribeOrganizationConformancePackStatusesWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConformancePackStatusesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConformancePackStatusesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConformancePackStatusesWithContext), varargs...) +} + +// DescribeOrganizationConformancePacks mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConformancePacks(arg0 *configservice.DescribeOrganizationConformancePacksInput) (*configservice.DescribeOrganizationConformancePacksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOrganizationConformancePacks", arg0) + ret0, _ := ret[0].(*configservice.DescribeOrganizationConformancePacksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOrganizationConformancePacks indicates an expected call of DescribeOrganizationConformancePacks +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConformancePacks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConformancePacks", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConformancePacks), arg0) +} + +// DescribeOrganizationConformancePacksRequest mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConformancePacksRequest(arg0 *configservice.DescribeOrganizationConformancePacksInput) (*request.Request, *configservice.DescribeOrganizationConformancePacksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeOrganizationConformancePacksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeOrganizationConformancePacksOutput) + return ret0, ret1 +} + +// DescribeOrganizationConformancePacksRequest indicates an expected call of DescribeOrganizationConformancePacksRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConformancePacksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConformancePacksRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConformancePacksRequest), arg0) +} + +// DescribeOrganizationConformancePacksWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeOrganizationConformancePacksWithContext(arg0 context.Context, arg1 *configservice.DescribeOrganizationConformancePacksInput, arg2 ...request.Option) (*configservice.DescribeOrganizationConformancePacksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeOrganizationConformancePacksWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeOrganizationConformancePacksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeOrganizationConformancePacksWithContext indicates an expected call of DescribeOrganizationConformancePacksWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeOrganizationConformancePacksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeOrganizationConformancePacksWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeOrganizationConformancePacksWithContext), varargs...) +} + +// DescribePendingAggregationRequests mocks base method +func (m *MockConfigServiceAPI) DescribePendingAggregationRequests(arg0 *configservice.DescribePendingAggregationRequestsInput) (*configservice.DescribePendingAggregationRequestsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePendingAggregationRequests", arg0) + ret0, _ := ret[0].(*configservice.DescribePendingAggregationRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePendingAggregationRequests indicates an expected call of DescribePendingAggregationRequests +func (mr *MockConfigServiceAPIMockRecorder) DescribePendingAggregationRequests(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePendingAggregationRequests", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribePendingAggregationRequests), arg0) +} + +// DescribePendingAggregationRequestsRequest mocks base method +func (m *MockConfigServiceAPI) DescribePendingAggregationRequestsRequest(arg0 *configservice.DescribePendingAggregationRequestsInput) (*request.Request, *configservice.DescribePendingAggregationRequestsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePendingAggregationRequestsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribePendingAggregationRequestsOutput) + return ret0, ret1 +} + +// DescribePendingAggregationRequestsRequest indicates an expected call of DescribePendingAggregationRequestsRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribePendingAggregationRequestsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePendingAggregationRequestsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribePendingAggregationRequestsRequest), arg0) +} + +// DescribePendingAggregationRequestsWithContext mocks base method +func (m *MockConfigServiceAPI) DescribePendingAggregationRequestsWithContext(arg0 context.Context, arg1 *configservice.DescribePendingAggregationRequestsInput, arg2 ...request.Option) (*configservice.DescribePendingAggregationRequestsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePendingAggregationRequestsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribePendingAggregationRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePendingAggregationRequestsWithContext indicates an expected call of DescribePendingAggregationRequestsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribePendingAggregationRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePendingAggregationRequestsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribePendingAggregationRequestsWithContext), varargs...) +} + +// DescribeRemediationConfigurations mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationConfigurations(arg0 *configservice.DescribeRemediationConfigurationsInput) (*configservice.DescribeRemediationConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRemediationConfigurations", arg0) + ret0, _ := ret[0].(*configservice.DescribeRemediationConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRemediationConfigurations indicates an expected call of DescribeRemediationConfigurations +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationConfigurations", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationConfigurations), arg0) +} + +// DescribeRemediationConfigurationsRequest mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationConfigurationsRequest(arg0 *configservice.DescribeRemediationConfigurationsInput) (*request.Request, *configservice.DescribeRemediationConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRemediationConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeRemediationConfigurationsOutput) + return ret0, ret1 +} + +// DescribeRemediationConfigurationsRequest indicates an expected call of DescribeRemediationConfigurationsRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationConfigurationsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationConfigurationsRequest), arg0) +} + +// DescribeRemediationConfigurationsWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationConfigurationsWithContext(arg0 context.Context, arg1 *configservice.DescribeRemediationConfigurationsInput, arg2 ...request.Option) (*configservice.DescribeRemediationConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRemediationConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeRemediationConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRemediationConfigurationsWithContext indicates an expected call of DescribeRemediationConfigurationsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationConfigurationsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationConfigurationsWithContext), varargs...) +} + +// DescribeRemediationExceptions mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExceptions(arg0 *configservice.DescribeRemediationExceptionsInput) (*configservice.DescribeRemediationExceptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRemediationExceptions", arg0) + ret0, _ := ret[0].(*configservice.DescribeRemediationExceptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRemediationExceptions indicates an expected call of DescribeRemediationExceptions +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExceptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExceptions", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExceptions), arg0) +} + +// DescribeRemediationExceptionsPages mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExceptionsPages(arg0 *configservice.DescribeRemediationExceptionsInput, arg1 func(*configservice.DescribeRemediationExceptionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRemediationExceptionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRemediationExceptionsPages indicates an expected call of DescribeRemediationExceptionsPages +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExceptionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExceptionsPages", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExceptionsPages), arg0, arg1) +} + +// DescribeRemediationExceptionsPagesWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExceptionsPagesWithContext(arg0 context.Context, arg1 *configservice.DescribeRemediationExceptionsInput, arg2 func(*configservice.DescribeRemediationExceptionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRemediationExceptionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRemediationExceptionsPagesWithContext indicates an expected call of DescribeRemediationExceptionsPagesWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExceptionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExceptionsPagesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExceptionsPagesWithContext), varargs...) +} + +// DescribeRemediationExceptionsRequest mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExceptionsRequest(arg0 *configservice.DescribeRemediationExceptionsInput) (*request.Request, *configservice.DescribeRemediationExceptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRemediationExceptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeRemediationExceptionsOutput) + return ret0, ret1 +} + +// DescribeRemediationExceptionsRequest indicates an expected call of DescribeRemediationExceptionsRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExceptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExceptionsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExceptionsRequest), arg0) +} + +// DescribeRemediationExceptionsWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExceptionsWithContext(arg0 context.Context, arg1 *configservice.DescribeRemediationExceptionsInput, arg2 ...request.Option) (*configservice.DescribeRemediationExceptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRemediationExceptionsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeRemediationExceptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRemediationExceptionsWithContext indicates an expected call of DescribeRemediationExceptionsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExceptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExceptionsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExceptionsWithContext), varargs...) +} + +// DescribeRemediationExecutionStatus mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExecutionStatus(arg0 *configservice.DescribeRemediationExecutionStatusInput) (*configservice.DescribeRemediationExecutionStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRemediationExecutionStatus", arg0) + ret0, _ := ret[0].(*configservice.DescribeRemediationExecutionStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRemediationExecutionStatus indicates an expected call of DescribeRemediationExecutionStatus +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExecutionStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExecutionStatus", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExecutionStatus), arg0) +} + +// DescribeRemediationExecutionStatusPages mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExecutionStatusPages(arg0 *configservice.DescribeRemediationExecutionStatusInput, arg1 func(*configservice.DescribeRemediationExecutionStatusOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRemediationExecutionStatusPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRemediationExecutionStatusPages indicates an expected call of DescribeRemediationExecutionStatusPages +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExecutionStatusPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExecutionStatusPages", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExecutionStatusPages), arg0, arg1) +} + +// DescribeRemediationExecutionStatusPagesWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExecutionStatusPagesWithContext(arg0 context.Context, arg1 *configservice.DescribeRemediationExecutionStatusInput, arg2 func(*configservice.DescribeRemediationExecutionStatusOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRemediationExecutionStatusPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRemediationExecutionStatusPagesWithContext indicates an expected call of DescribeRemediationExecutionStatusPagesWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExecutionStatusPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExecutionStatusPagesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExecutionStatusPagesWithContext), varargs...) +} + +// DescribeRemediationExecutionStatusRequest mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExecutionStatusRequest(arg0 *configservice.DescribeRemediationExecutionStatusInput) (*request.Request, *configservice.DescribeRemediationExecutionStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRemediationExecutionStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeRemediationExecutionStatusOutput) + return ret0, ret1 +} + +// DescribeRemediationExecutionStatusRequest indicates an expected call of DescribeRemediationExecutionStatusRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExecutionStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExecutionStatusRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExecutionStatusRequest), arg0) +} + +// DescribeRemediationExecutionStatusWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeRemediationExecutionStatusWithContext(arg0 context.Context, arg1 *configservice.DescribeRemediationExecutionStatusInput, arg2 ...request.Option) (*configservice.DescribeRemediationExecutionStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRemediationExecutionStatusWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeRemediationExecutionStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRemediationExecutionStatusWithContext indicates an expected call of DescribeRemediationExecutionStatusWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeRemediationExecutionStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRemediationExecutionStatusWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRemediationExecutionStatusWithContext), varargs...) +} + +// DescribeRetentionConfigurations mocks base method +func (m *MockConfigServiceAPI) DescribeRetentionConfigurations(arg0 *configservice.DescribeRetentionConfigurationsInput) (*configservice.DescribeRetentionConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRetentionConfigurations", arg0) + ret0, _ := ret[0].(*configservice.DescribeRetentionConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRetentionConfigurations indicates an expected call of DescribeRetentionConfigurations +func (mr *MockConfigServiceAPIMockRecorder) DescribeRetentionConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRetentionConfigurations", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRetentionConfigurations), arg0) +} + +// DescribeRetentionConfigurationsRequest mocks base method +func (m *MockConfigServiceAPI) DescribeRetentionConfigurationsRequest(arg0 *configservice.DescribeRetentionConfigurationsInput) (*request.Request, *configservice.DescribeRetentionConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRetentionConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.DescribeRetentionConfigurationsOutput) + return ret0, ret1 +} + +// DescribeRetentionConfigurationsRequest indicates an expected call of DescribeRetentionConfigurationsRequest +func (mr *MockConfigServiceAPIMockRecorder) DescribeRetentionConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRetentionConfigurationsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRetentionConfigurationsRequest), arg0) +} + +// DescribeRetentionConfigurationsWithContext mocks base method +func (m *MockConfigServiceAPI) DescribeRetentionConfigurationsWithContext(arg0 context.Context, arg1 *configservice.DescribeRetentionConfigurationsInput, arg2 ...request.Option) (*configservice.DescribeRetentionConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRetentionConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.DescribeRetentionConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRetentionConfigurationsWithContext indicates an expected call of DescribeRetentionConfigurationsWithContext +func (mr *MockConfigServiceAPIMockRecorder) DescribeRetentionConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRetentionConfigurationsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).DescribeRetentionConfigurationsWithContext), varargs...) +} + +// GetAggregateComplianceDetailsByConfigRule mocks base method +func (m *MockConfigServiceAPI) GetAggregateComplianceDetailsByConfigRule(arg0 *configservice.GetAggregateComplianceDetailsByConfigRuleInput) (*configservice.GetAggregateComplianceDetailsByConfigRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAggregateComplianceDetailsByConfigRule", arg0) + ret0, _ := ret[0].(*configservice.GetAggregateComplianceDetailsByConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAggregateComplianceDetailsByConfigRule indicates an expected call of GetAggregateComplianceDetailsByConfigRule +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateComplianceDetailsByConfigRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateComplianceDetailsByConfigRule", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateComplianceDetailsByConfigRule), arg0) +} + +// GetAggregateComplianceDetailsByConfigRuleRequest mocks base method +func (m *MockConfigServiceAPI) GetAggregateComplianceDetailsByConfigRuleRequest(arg0 *configservice.GetAggregateComplianceDetailsByConfigRuleInput) (*request.Request, *configservice.GetAggregateComplianceDetailsByConfigRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAggregateComplianceDetailsByConfigRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetAggregateComplianceDetailsByConfigRuleOutput) + return ret0, ret1 +} + +// GetAggregateComplianceDetailsByConfigRuleRequest indicates an expected call of GetAggregateComplianceDetailsByConfigRuleRequest +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateComplianceDetailsByConfigRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateComplianceDetailsByConfigRuleRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateComplianceDetailsByConfigRuleRequest), arg0) +} + +// GetAggregateComplianceDetailsByConfigRuleWithContext mocks base method +func (m *MockConfigServiceAPI) GetAggregateComplianceDetailsByConfigRuleWithContext(arg0 context.Context, arg1 *configservice.GetAggregateComplianceDetailsByConfigRuleInput, arg2 ...request.Option) (*configservice.GetAggregateComplianceDetailsByConfigRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAggregateComplianceDetailsByConfigRuleWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetAggregateComplianceDetailsByConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAggregateComplianceDetailsByConfigRuleWithContext indicates an expected call of GetAggregateComplianceDetailsByConfigRuleWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateComplianceDetailsByConfigRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateComplianceDetailsByConfigRuleWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateComplianceDetailsByConfigRuleWithContext), varargs...) +} + +// GetAggregateConfigRuleComplianceSummary mocks base method +func (m *MockConfigServiceAPI) GetAggregateConfigRuleComplianceSummary(arg0 *configservice.GetAggregateConfigRuleComplianceSummaryInput) (*configservice.GetAggregateConfigRuleComplianceSummaryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAggregateConfigRuleComplianceSummary", arg0) + ret0, _ := ret[0].(*configservice.GetAggregateConfigRuleComplianceSummaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAggregateConfigRuleComplianceSummary indicates an expected call of GetAggregateConfigRuleComplianceSummary +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateConfigRuleComplianceSummary(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateConfigRuleComplianceSummary", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateConfigRuleComplianceSummary), arg0) +} + +// GetAggregateConfigRuleComplianceSummaryRequest mocks base method +func (m *MockConfigServiceAPI) GetAggregateConfigRuleComplianceSummaryRequest(arg0 *configservice.GetAggregateConfigRuleComplianceSummaryInput) (*request.Request, *configservice.GetAggregateConfigRuleComplianceSummaryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAggregateConfigRuleComplianceSummaryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetAggregateConfigRuleComplianceSummaryOutput) + return ret0, ret1 +} + +// GetAggregateConfigRuleComplianceSummaryRequest indicates an expected call of GetAggregateConfigRuleComplianceSummaryRequest +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateConfigRuleComplianceSummaryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateConfigRuleComplianceSummaryRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateConfigRuleComplianceSummaryRequest), arg0) +} + +// GetAggregateConfigRuleComplianceSummaryWithContext mocks base method +func (m *MockConfigServiceAPI) GetAggregateConfigRuleComplianceSummaryWithContext(arg0 context.Context, arg1 *configservice.GetAggregateConfigRuleComplianceSummaryInput, arg2 ...request.Option) (*configservice.GetAggregateConfigRuleComplianceSummaryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAggregateConfigRuleComplianceSummaryWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetAggregateConfigRuleComplianceSummaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAggregateConfigRuleComplianceSummaryWithContext indicates an expected call of GetAggregateConfigRuleComplianceSummaryWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateConfigRuleComplianceSummaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateConfigRuleComplianceSummaryWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateConfigRuleComplianceSummaryWithContext), varargs...) +} + +// GetAggregateDiscoveredResourceCounts mocks base method +func (m *MockConfigServiceAPI) GetAggregateDiscoveredResourceCounts(arg0 *configservice.GetAggregateDiscoveredResourceCountsInput) (*configservice.GetAggregateDiscoveredResourceCountsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAggregateDiscoveredResourceCounts", arg0) + ret0, _ := ret[0].(*configservice.GetAggregateDiscoveredResourceCountsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAggregateDiscoveredResourceCounts indicates an expected call of GetAggregateDiscoveredResourceCounts +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateDiscoveredResourceCounts(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateDiscoveredResourceCounts", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateDiscoveredResourceCounts), arg0) +} + +// GetAggregateDiscoveredResourceCountsRequest mocks base method +func (m *MockConfigServiceAPI) GetAggregateDiscoveredResourceCountsRequest(arg0 *configservice.GetAggregateDiscoveredResourceCountsInput) (*request.Request, *configservice.GetAggregateDiscoveredResourceCountsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAggregateDiscoveredResourceCountsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetAggregateDiscoveredResourceCountsOutput) + return ret0, ret1 +} + +// GetAggregateDiscoveredResourceCountsRequest indicates an expected call of GetAggregateDiscoveredResourceCountsRequest +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateDiscoveredResourceCountsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateDiscoveredResourceCountsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateDiscoveredResourceCountsRequest), arg0) +} + +// GetAggregateDiscoveredResourceCountsWithContext mocks base method +func (m *MockConfigServiceAPI) GetAggregateDiscoveredResourceCountsWithContext(arg0 context.Context, arg1 *configservice.GetAggregateDiscoveredResourceCountsInput, arg2 ...request.Option) (*configservice.GetAggregateDiscoveredResourceCountsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAggregateDiscoveredResourceCountsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetAggregateDiscoveredResourceCountsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAggregateDiscoveredResourceCountsWithContext indicates an expected call of GetAggregateDiscoveredResourceCountsWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateDiscoveredResourceCountsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateDiscoveredResourceCountsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateDiscoveredResourceCountsWithContext), varargs...) +} + +// GetAggregateResourceConfig mocks base method +func (m *MockConfigServiceAPI) GetAggregateResourceConfig(arg0 *configservice.GetAggregateResourceConfigInput) (*configservice.GetAggregateResourceConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAggregateResourceConfig", arg0) + ret0, _ := ret[0].(*configservice.GetAggregateResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAggregateResourceConfig indicates an expected call of GetAggregateResourceConfig +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateResourceConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateResourceConfig", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateResourceConfig), arg0) +} + +// GetAggregateResourceConfigRequest mocks base method +func (m *MockConfigServiceAPI) GetAggregateResourceConfigRequest(arg0 *configservice.GetAggregateResourceConfigInput) (*request.Request, *configservice.GetAggregateResourceConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAggregateResourceConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetAggregateResourceConfigOutput) + return ret0, ret1 +} + +// GetAggregateResourceConfigRequest indicates an expected call of GetAggregateResourceConfigRequest +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateResourceConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateResourceConfigRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateResourceConfigRequest), arg0) +} + +// GetAggregateResourceConfigWithContext mocks base method +func (m *MockConfigServiceAPI) GetAggregateResourceConfigWithContext(arg0 context.Context, arg1 *configservice.GetAggregateResourceConfigInput, arg2 ...request.Option) (*configservice.GetAggregateResourceConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAggregateResourceConfigWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetAggregateResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAggregateResourceConfigWithContext indicates an expected call of GetAggregateResourceConfigWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetAggregateResourceConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAggregateResourceConfigWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetAggregateResourceConfigWithContext), varargs...) +} + +// GetComplianceDetailsByConfigRule mocks base method +func (m *MockConfigServiceAPI) GetComplianceDetailsByConfigRule(arg0 *configservice.GetComplianceDetailsByConfigRuleInput) (*configservice.GetComplianceDetailsByConfigRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComplianceDetailsByConfigRule", arg0) + ret0, _ := ret[0].(*configservice.GetComplianceDetailsByConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComplianceDetailsByConfigRule indicates an expected call of GetComplianceDetailsByConfigRule +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceDetailsByConfigRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceDetailsByConfigRule", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceDetailsByConfigRule), arg0) +} + +// GetComplianceDetailsByConfigRuleRequest mocks base method +func (m *MockConfigServiceAPI) GetComplianceDetailsByConfigRuleRequest(arg0 *configservice.GetComplianceDetailsByConfigRuleInput) (*request.Request, *configservice.GetComplianceDetailsByConfigRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComplianceDetailsByConfigRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetComplianceDetailsByConfigRuleOutput) + return ret0, ret1 +} + +// GetComplianceDetailsByConfigRuleRequest indicates an expected call of GetComplianceDetailsByConfigRuleRequest +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceDetailsByConfigRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceDetailsByConfigRuleRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceDetailsByConfigRuleRequest), arg0) +} + +// GetComplianceDetailsByConfigRuleWithContext mocks base method +func (m *MockConfigServiceAPI) GetComplianceDetailsByConfigRuleWithContext(arg0 context.Context, arg1 *configservice.GetComplianceDetailsByConfigRuleInput, arg2 ...request.Option) (*configservice.GetComplianceDetailsByConfigRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetComplianceDetailsByConfigRuleWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetComplianceDetailsByConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComplianceDetailsByConfigRuleWithContext indicates an expected call of GetComplianceDetailsByConfigRuleWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceDetailsByConfigRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceDetailsByConfigRuleWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceDetailsByConfigRuleWithContext), varargs...) +} + +// GetComplianceDetailsByResource mocks base method +func (m *MockConfigServiceAPI) GetComplianceDetailsByResource(arg0 *configservice.GetComplianceDetailsByResourceInput) (*configservice.GetComplianceDetailsByResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComplianceDetailsByResource", arg0) + ret0, _ := ret[0].(*configservice.GetComplianceDetailsByResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComplianceDetailsByResource indicates an expected call of GetComplianceDetailsByResource +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceDetailsByResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceDetailsByResource", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceDetailsByResource), arg0) +} + +// GetComplianceDetailsByResourceRequest mocks base method +func (m *MockConfigServiceAPI) GetComplianceDetailsByResourceRequest(arg0 *configservice.GetComplianceDetailsByResourceInput) (*request.Request, *configservice.GetComplianceDetailsByResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComplianceDetailsByResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetComplianceDetailsByResourceOutput) + return ret0, ret1 +} + +// GetComplianceDetailsByResourceRequest indicates an expected call of GetComplianceDetailsByResourceRequest +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceDetailsByResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceDetailsByResourceRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceDetailsByResourceRequest), arg0) +} + +// GetComplianceDetailsByResourceWithContext mocks base method +func (m *MockConfigServiceAPI) GetComplianceDetailsByResourceWithContext(arg0 context.Context, arg1 *configservice.GetComplianceDetailsByResourceInput, arg2 ...request.Option) (*configservice.GetComplianceDetailsByResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetComplianceDetailsByResourceWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetComplianceDetailsByResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComplianceDetailsByResourceWithContext indicates an expected call of GetComplianceDetailsByResourceWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceDetailsByResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceDetailsByResourceWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceDetailsByResourceWithContext), varargs...) +} + +// GetComplianceSummaryByConfigRule mocks base method +func (m *MockConfigServiceAPI) GetComplianceSummaryByConfigRule(arg0 *configservice.GetComplianceSummaryByConfigRuleInput) (*configservice.GetComplianceSummaryByConfigRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComplianceSummaryByConfigRule", arg0) + ret0, _ := ret[0].(*configservice.GetComplianceSummaryByConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComplianceSummaryByConfigRule indicates an expected call of GetComplianceSummaryByConfigRule +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceSummaryByConfigRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummaryByConfigRule", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceSummaryByConfigRule), arg0) +} + +// GetComplianceSummaryByConfigRuleRequest mocks base method +func (m *MockConfigServiceAPI) GetComplianceSummaryByConfigRuleRequest(arg0 *configservice.GetComplianceSummaryByConfigRuleInput) (*request.Request, *configservice.GetComplianceSummaryByConfigRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComplianceSummaryByConfigRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetComplianceSummaryByConfigRuleOutput) + return ret0, ret1 +} + +// GetComplianceSummaryByConfigRuleRequest indicates an expected call of GetComplianceSummaryByConfigRuleRequest +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceSummaryByConfigRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummaryByConfigRuleRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceSummaryByConfigRuleRequest), arg0) +} + +// GetComplianceSummaryByConfigRuleWithContext mocks base method +func (m *MockConfigServiceAPI) GetComplianceSummaryByConfigRuleWithContext(arg0 context.Context, arg1 *configservice.GetComplianceSummaryByConfigRuleInput, arg2 ...request.Option) (*configservice.GetComplianceSummaryByConfigRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetComplianceSummaryByConfigRuleWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetComplianceSummaryByConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComplianceSummaryByConfigRuleWithContext indicates an expected call of GetComplianceSummaryByConfigRuleWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceSummaryByConfigRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummaryByConfigRuleWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceSummaryByConfigRuleWithContext), varargs...) +} + +// GetComplianceSummaryByResourceType mocks base method +func (m *MockConfigServiceAPI) GetComplianceSummaryByResourceType(arg0 *configservice.GetComplianceSummaryByResourceTypeInput) (*configservice.GetComplianceSummaryByResourceTypeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComplianceSummaryByResourceType", arg0) + ret0, _ := ret[0].(*configservice.GetComplianceSummaryByResourceTypeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComplianceSummaryByResourceType indicates an expected call of GetComplianceSummaryByResourceType +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceSummaryByResourceType(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummaryByResourceType", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceSummaryByResourceType), arg0) +} + +// GetComplianceSummaryByResourceTypeRequest mocks base method +func (m *MockConfigServiceAPI) GetComplianceSummaryByResourceTypeRequest(arg0 *configservice.GetComplianceSummaryByResourceTypeInput) (*request.Request, *configservice.GetComplianceSummaryByResourceTypeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetComplianceSummaryByResourceTypeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetComplianceSummaryByResourceTypeOutput) + return ret0, ret1 +} + +// GetComplianceSummaryByResourceTypeRequest indicates an expected call of GetComplianceSummaryByResourceTypeRequest +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceSummaryByResourceTypeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummaryByResourceTypeRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceSummaryByResourceTypeRequest), arg0) +} + +// GetComplianceSummaryByResourceTypeWithContext mocks base method +func (m *MockConfigServiceAPI) GetComplianceSummaryByResourceTypeWithContext(arg0 context.Context, arg1 *configservice.GetComplianceSummaryByResourceTypeInput, arg2 ...request.Option) (*configservice.GetComplianceSummaryByResourceTypeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetComplianceSummaryByResourceTypeWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetComplianceSummaryByResourceTypeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetComplianceSummaryByResourceTypeWithContext indicates an expected call of GetComplianceSummaryByResourceTypeWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetComplianceSummaryByResourceTypeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetComplianceSummaryByResourceTypeWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetComplianceSummaryByResourceTypeWithContext), varargs...) +} + +// GetConformancePackComplianceDetails mocks base method +func (m *MockConfigServiceAPI) GetConformancePackComplianceDetails(arg0 *configservice.GetConformancePackComplianceDetailsInput) (*configservice.GetConformancePackComplianceDetailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConformancePackComplianceDetails", arg0) + ret0, _ := ret[0].(*configservice.GetConformancePackComplianceDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConformancePackComplianceDetails indicates an expected call of GetConformancePackComplianceDetails +func (mr *MockConfigServiceAPIMockRecorder) GetConformancePackComplianceDetails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConformancePackComplianceDetails", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetConformancePackComplianceDetails), arg0) +} + +// GetConformancePackComplianceDetailsRequest mocks base method +func (m *MockConfigServiceAPI) GetConformancePackComplianceDetailsRequest(arg0 *configservice.GetConformancePackComplianceDetailsInput) (*request.Request, *configservice.GetConformancePackComplianceDetailsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConformancePackComplianceDetailsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetConformancePackComplianceDetailsOutput) + return ret0, ret1 +} + +// GetConformancePackComplianceDetailsRequest indicates an expected call of GetConformancePackComplianceDetailsRequest +func (mr *MockConfigServiceAPIMockRecorder) GetConformancePackComplianceDetailsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConformancePackComplianceDetailsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetConformancePackComplianceDetailsRequest), arg0) +} + +// GetConformancePackComplianceDetailsWithContext mocks base method +func (m *MockConfigServiceAPI) GetConformancePackComplianceDetailsWithContext(arg0 context.Context, arg1 *configservice.GetConformancePackComplianceDetailsInput, arg2 ...request.Option) (*configservice.GetConformancePackComplianceDetailsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetConformancePackComplianceDetailsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetConformancePackComplianceDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConformancePackComplianceDetailsWithContext indicates an expected call of GetConformancePackComplianceDetailsWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetConformancePackComplianceDetailsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConformancePackComplianceDetailsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetConformancePackComplianceDetailsWithContext), varargs...) +} + +// GetConformancePackComplianceSummary mocks base method +func (m *MockConfigServiceAPI) GetConformancePackComplianceSummary(arg0 *configservice.GetConformancePackComplianceSummaryInput) (*configservice.GetConformancePackComplianceSummaryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConformancePackComplianceSummary", arg0) + ret0, _ := ret[0].(*configservice.GetConformancePackComplianceSummaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConformancePackComplianceSummary indicates an expected call of GetConformancePackComplianceSummary +func (mr *MockConfigServiceAPIMockRecorder) GetConformancePackComplianceSummary(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConformancePackComplianceSummary", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetConformancePackComplianceSummary), arg0) +} + +// GetConformancePackComplianceSummaryRequest mocks base method +func (m *MockConfigServiceAPI) GetConformancePackComplianceSummaryRequest(arg0 *configservice.GetConformancePackComplianceSummaryInput) (*request.Request, *configservice.GetConformancePackComplianceSummaryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConformancePackComplianceSummaryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetConformancePackComplianceSummaryOutput) + return ret0, ret1 +} + +// GetConformancePackComplianceSummaryRequest indicates an expected call of GetConformancePackComplianceSummaryRequest +func (mr *MockConfigServiceAPIMockRecorder) GetConformancePackComplianceSummaryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConformancePackComplianceSummaryRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetConformancePackComplianceSummaryRequest), arg0) +} + +// GetConformancePackComplianceSummaryWithContext mocks base method +func (m *MockConfigServiceAPI) GetConformancePackComplianceSummaryWithContext(arg0 context.Context, arg1 *configservice.GetConformancePackComplianceSummaryInput, arg2 ...request.Option) (*configservice.GetConformancePackComplianceSummaryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetConformancePackComplianceSummaryWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetConformancePackComplianceSummaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConformancePackComplianceSummaryWithContext indicates an expected call of GetConformancePackComplianceSummaryWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetConformancePackComplianceSummaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConformancePackComplianceSummaryWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetConformancePackComplianceSummaryWithContext), varargs...) +} + +// GetDiscoveredResourceCounts mocks base method +func (m *MockConfigServiceAPI) GetDiscoveredResourceCounts(arg0 *configservice.GetDiscoveredResourceCountsInput) (*configservice.GetDiscoveredResourceCountsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDiscoveredResourceCounts", arg0) + ret0, _ := ret[0].(*configservice.GetDiscoveredResourceCountsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDiscoveredResourceCounts indicates an expected call of GetDiscoveredResourceCounts +func (mr *MockConfigServiceAPIMockRecorder) GetDiscoveredResourceCounts(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiscoveredResourceCounts", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetDiscoveredResourceCounts), arg0) +} + +// GetDiscoveredResourceCountsRequest mocks base method +func (m *MockConfigServiceAPI) GetDiscoveredResourceCountsRequest(arg0 *configservice.GetDiscoveredResourceCountsInput) (*request.Request, *configservice.GetDiscoveredResourceCountsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDiscoveredResourceCountsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetDiscoveredResourceCountsOutput) + return ret0, ret1 +} + +// GetDiscoveredResourceCountsRequest indicates an expected call of GetDiscoveredResourceCountsRequest +func (mr *MockConfigServiceAPIMockRecorder) GetDiscoveredResourceCountsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiscoveredResourceCountsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetDiscoveredResourceCountsRequest), arg0) +} + +// GetDiscoveredResourceCountsWithContext mocks base method +func (m *MockConfigServiceAPI) GetDiscoveredResourceCountsWithContext(arg0 context.Context, arg1 *configservice.GetDiscoveredResourceCountsInput, arg2 ...request.Option) (*configservice.GetDiscoveredResourceCountsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetDiscoveredResourceCountsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetDiscoveredResourceCountsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDiscoveredResourceCountsWithContext indicates an expected call of GetDiscoveredResourceCountsWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetDiscoveredResourceCountsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiscoveredResourceCountsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetDiscoveredResourceCountsWithContext), varargs...) +} + +// GetOrganizationConfigRuleDetailedStatus mocks base method +func (m *MockConfigServiceAPI) GetOrganizationConfigRuleDetailedStatus(arg0 *configservice.GetOrganizationConfigRuleDetailedStatusInput) (*configservice.GetOrganizationConfigRuleDetailedStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrganizationConfigRuleDetailedStatus", arg0) + ret0, _ := ret[0].(*configservice.GetOrganizationConfigRuleDetailedStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrganizationConfigRuleDetailedStatus indicates an expected call of GetOrganizationConfigRuleDetailedStatus +func (mr *MockConfigServiceAPIMockRecorder) GetOrganizationConfigRuleDetailedStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationConfigRuleDetailedStatus", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetOrganizationConfigRuleDetailedStatus), arg0) +} + +// GetOrganizationConfigRuleDetailedStatusRequest mocks base method +func (m *MockConfigServiceAPI) GetOrganizationConfigRuleDetailedStatusRequest(arg0 *configservice.GetOrganizationConfigRuleDetailedStatusInput) (*request.Request, *configservice.GetOrganizationConfigRuleDetailedStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrganizationConfigRuleDetailedStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetOrganizationConfigRuleDetailedStatusOutput) + return ret0, ret1 +} + +// GetOrganizationConfigRuleDetailedStatusRequest indicates an expected call of GetOrganizationConfigRuleDetailedStatusRequest +func (mr *MockConfigServiceAPIMockRecorder) GetOrganizationConfigRuleDetailedStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationConfigRuleDetailedStatusRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetOrganizationConfigRuleDetailedStatusRequest), arg0) +} + +// GetOrganizationConfigRuleDetailedStatusWithContext mocks base method +func (m *MockConfigServiceAPI) GetOrganizationConfigRuleDetailedStatusWithContext(arg0 context.Context, arg1 *configservice.GetOrganizationConfigRuleDetailedStatusInput, arg2 ...request.Option) (*configservice.GetOrganizationConfigRuleDetailedStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOrganizationConfigRuleDetailedStatusWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetOrganizationConfigRuleDetailedStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrganizationConfigRuleDetailedStatusWithContext indicates an expected call of GetOrganizationConfigRuleDetailedStatusWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetOrganizationConfigRuleDetailedStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationConfigRuleDetailedStatusWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetOrganizationConfigRuleDetailedStatusWithContext), varargs...) +} + +// GetOrganizationConformancePackDetailedStatus mocks base method +func (m *MockConfigServiceAPI) GetOrganizationConformancePackDetailedStatus(arg0 *configservice.GetOrganizationConformancePackDetailedStatusInput) (*configservice.GetOrganizationConformancePackDetailedStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrganizationConformancePackDetailedStatus", arg0) + ret0, _ := ret[0].(*configservice.GetOrganizationConformancePackDetailedStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrganizationConformancePackDetailedStatus indicates an expected call of GetOrganizationConformancePackDetailedStatus +func (mr *MockConfigServiceAPIMockRecorder) GetOrganizationConformancePackDetailedStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationConformancePackDetailedStatus", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetOrganizationConformancePackDetailedStatus), arg0) +} + +// GetOrganizationConformancePackDetailedStatusRequest mocks base method +func (m *MockConfigServiceAPI) GetOrganizationConformancePackDetailedStatusRequest(arg0 *configservice.GetOrganizationConformancePackDetailedStatusInput) (*request.Request, *configservice.GetOrganizationConformancePackDetailedStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrganizationConformancePackDetailedStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetOrganizationConformancePackDetailedStatusOutput) + return ret0, ret1 +} + +// GetOrganizationConformancePackDetailedStatusRequest indicates an expected call of GetOrganizationConformancePackDetailedStatusRequest +func (mr *MockConfigServiceAPIMockRecorder) GetOrganizationConformancePackDetailedStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationConformancePackDetailedStatusRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetOrganizationConformancePackDetailedStatusRequest), arg0) +} + +// GetOrganizationConformancePackDetailedStatusWithContext mocks base method +func (m *MockConfigServiceAPI) GetOrganizationConformancePackDetailedStatusWithContext(arg0 context.Context, arg1 *configservice.GetOrganizationConformancePackDetailedStatusInput, arg2 ...request.Option) (*configservice.GetOrganizationConformancePackDetailedStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOrganizationConformancePackDetailedStatusWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetOrganizationConformancePackDetailedStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrganizationConformancePackDetailedStatusWithContext indicates an expected call of GetOrganizationConformancePackDetailedStatusWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetOrganizationConformancePackDetailedStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationConformancePackDetailedStatusWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetOrganizationConformancePackDetailedStatusWithContext), varargs...) +} + +// GetResourceConfigHistory mocks base method +func (m *MockConfigServiceAPI) GetResourceConfigHistory(arg0 *configservice.GetResourceConfigHistoryInput) (*configservice.GetResourceConfigHistoryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResourceConfigHistory", arg0) + ret0, _ := ret[0].(*configservice.GetResourceConfigHistoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResourceConfigHistory indicates an expected call of GetResourceConfigHistory +func (mr *MockConfigServiceAPIMockRecorder) GetResourceConfigHistory(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceConfigHistory", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetResourceConfigHistory), arg0) +} + +// GetResourceConfigHistoryPages mocks base method +func (m *MockConfigServiceAPI) GetResourceConfigHistoryPages(arg0 *configservice.GetResourceConfigHistoryInput, arg1 func(*configservice.GetResourceConfigHistoryOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResourceConfigHistoryPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetResourceConfigHistoryPages indicates an expected call of GetResourceConfigHistoryPages +func (mr *MockConfigServiceAPIMockRecorder) GetResourceConfigHistoryPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceConfigHistoryPages", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetResourceConfigHistoryPages), arg0, arg1) +} + +// GetResourceConfigHistoryPagesWithContext mocks base method +func (m *MockConfigServiceAPI) GetResourceConfigHistoryPagesWithContext(arg0 context.Context, arg1 *configservice.GetResourceConfigHistoryInput, arg2 func(*configservice.GetResourceConfigHistoryOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResourceConfigHistoryPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetResourceConfigHistoryPagesWithContext indicates an expected call of GetResourceConfigHistoryPagesWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetResourceConfigHistoryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceConfigHistoryPagesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetResourceConfigHistoryPagesWithContext), varargs...) +} + +// GetResourceConfigHistoryRequest mocks base method +func (m *MockConfigServiceAPI) GetResourceConfigHistoryRequest(arg0 *configservice.GetResourceConfigHistoryInput) (*request.Request, *configservice.GetResourceConfigHistoryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResourceConfigHistoryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.GetResourceConfigHistoryOutput) + return ret0, ret1 +} + +// GetResourceConfigHistoryRequest indicates an expected call of GetResourceConfigHistoryRequest +func (mr *MockConfigServiceAPIMockRecorder) GetResourceConfigHistoryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceConfigHistoryRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetResourceConfigHistoryRequest), arg0) +} + +// GetResourceConfigHistoryWithContext mocks base method +func (m *MockConfigServiceAPI) GetResourceConfigHistoryWithContext(arg0 context.Context, arg1 *configservice.GetResourceConfigHistoryInput, arg2 ...request.Option) (*configservice.GetResourceConfigHistoryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetResourceConfigHistoryWithContext", varargs...) + ret0, _ := ret[0].(*configservice.GetResourceConfigHistoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResourceConfigHistoryWithContext indicates an expected call of GetResourceConfigHistoryWithContext +func (mr *MockConfigServiceAPIMockRecorder) GetResourceConfigHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceConfigHistoryWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).GetResourceConfigHistoryWithContext), varargs...) +} + +// ListAggregateDiscoveredResources mocks base method +func (m *MockConfigServiceAPI) ListAggregateDiscoveredResources(arg0 *configservice.ListAggregateDiscoveredResourcesInput) (*configservice.ListAggregateDiscoveredResourcesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAggregateDiscoveredResources", arg0) + ret0, _ := ret[0].(*configservice.ListAggregateDiscoveredResourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAggregateDiscoveredResources indicates an expected call of ListAggregateDiscoveredResources +func (mr *MockConfigServiceAPIMockRecorder) ListAggregateDiscoveredResources(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAggregateDiscoveredResources", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListAggregateDiscoveredResources), arg0) +} + +// ListAggregateDiscoveredResourcesRequest mocks base method +func (m *MockConfigServiceAPI) ListAggregateDiscoveredResourcesRequest(arg0 *configservice.ListAggregateDiscoveredResourcesInput) (*request.Request, *configservice.ListAggregateDiscoveredResourcesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAggregateDiscoveredResourcesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.ListAggregateDiscoveredResourcesOutput) + return ret0, ret1 +} + +// ListAggregateDiscoveredResourcesRequest indicates an expected call of ListAggregateDiscoveredResourcesRequest +func (mr *MockConfigServiceAPIMockRecorder) ListAggregateDiscoveredResourcesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAggregateDiscoveredResourcesRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListAggregateDiscoveredResourcesRequest), arg0) +} + +// ListAggregateDiscoveredResourcesWithContext mocks base method +func (m *MockConfigServiceAPI) ListAggregateDiscoveredResourcesWithContext(arg0 context.Context, arg1 *configservice.ListAggregateDiscoveredResourcesInput, arg2 ...request.Option) (*configservice.ListAggregateDiscoveredResourcesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAggregateDiscoveredResourcesWithContext", varargs...) + ret0, _ := ret[0].(*configservice.ListAggregateDiscoveredResourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAggregateDiscoveredResourcesWithContext indicates an expected call of ListAggregateDiscoveredResourcesWithContext +func (mr *MockConfigServiceAPIMockRecorder) ListAggregateDiscoveredResourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAggregateDiscoveredResourcesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListAggregateDiscoveredResourcesWithContext), varargs...) +} + +// ListDiscoveredResources mocks base method +func (m *MockConfigServiceAPI) ListDiscoveredResources(arg0 *configservice.ListDiscoveredResourcesInput) (*configservice.ListDiscoveredResourcesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDiscoveredResources", arg0) + ret0, _ := ret[0].(*configservice.ListDiscoveredResourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDiscoveredResources indicates an expected call of ListDiscoveredResources +func (mr *MockConfigServiceAPIMockRecorder) ListDiscoveredResources(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDiscoveredResources", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListDiscoveredResources), arg0) +} + +// ListDiscoveredResourcesRequest mocks base method +func (m *MockConfigServiceAPI) ListDiscoveredResourcesRequest(arg0 *configservice.ListDiscoveredResourcesInput) (*request.Request, *configservice.ListDiscoveredResourcesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDiscoveredResourcesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.ListDiscoveredResourcesOutput) + return ret0, ret1 +} + +// ListDiscoveredResourcesRequest indicates an expected call of ListDiscoveredResourcesRequest +func (mr *MockConfigServiceAPIMockRecorder) ListDiscoveredResourcesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDiscoveredResourcesRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListDiscoveredResourcesRequest), arg0) +} + +// ListDiscoveredResourcesWithContext mocks base method +func (m *MockConfigServiceAPI) ListDiscoveredResourcesWithContext(arg0 context.Context, arg1 *configservice.ListDiscoveredResourcesInput, arg2 ...request.Option) (*configservice.ListDiscoveredResourcesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDiscoveredResourcesWithContext", varargs...) + ret0, _ := ret[0].(*configservice.ListDiscoveredResourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDiscoveredResourcesWithContext indicates an expected call of ListDiscoveredResourcesWithContext +func (mr *MockConfigServiceAPIMockRecorder) ListDiscoveredResourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDiscoveredResourcesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListDiscoveredResourcesWithContext), varargs...) +} + +// ListTagsForResource mocks base method +func (m *MockConfigServiceAPI) ListTagsForResource(arg0 *configservice.ListTagsForResourceInput) (*configservice.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResource", arg0) + ret0, _ := ret[0].(*configservice.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResource indicates an expected call of ListTagsForResource +func (mr *MockConfigServiceAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListTagsForResource), arg0) +} + +// ListTagsForResourceRequest mocks base method +func (m *MockConfigServiceAPI) ListTagsForResourceRequest(arg0 *configservice.ListTagsForResourceInput) (*request.Request, *configservice.ListTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.ListTagsForResourceOutput) + return ret0, ret1 +} + +// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest +func (mr *MockConfigServiceAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListTagsForResourceRequest), arg0) +} + +// ListTagsForResourceWithContext mocks base method +func (m *MockConfigServiceAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *configservice.ListTagsForResourceInput, arg2 ...request.Option) (*configservice.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) + ret0, _ := ret[0].(*configservice.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext +func (mr *MockConfigServiceAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).ListTagsForResourceWithContext), varargs...) +} + +// PutAggregationAuthorization mocks base method +func (m *MockConfigServiceAPI) PutAggregationAuthorization(arg0 *configservice.PutAggregationAuthorizationInput) (*configservice.PutAggregationAuthorizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutAggregationAuthorization", arg0) + ret0, _ := ret[0].(*configservice.PutAggregationAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutAggregationAuthorization indicates an expected call of PutAggregationAuthorization +func (mr *MockConfigServiceAPIMockRecorder) PutAggregationAuthorization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAggregationAuthorization", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutAggregationAuthorization), arg0) +} + +// PutAggregationAuthorizationRequest mocks base method +func (m *MockConfigServiceAPI) PutAggregationAuthorizationRequest(arg0 *configservice.PutAggregationAuthorizationInput) (*request.Request, *configservice.PutAggregationAuthorizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutAggregationAuthorizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutAggregationAuthorizationOutput) + return ret0, ret1 +} + +// PutAggregationAuthorizationRequest indicates an expected call of PutAggregationAuthorizationRequest +func (mr *MockConfigServiceAPIMockRecorder) PutAggregationAuthorizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAggregationAuthorizationRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutAggregationAuthorizationRequest), arg0) +} + +// PutAggregationAuthorizationWithContext mocks base method +func (m *MockConfigServiceAPI) PutAggregationAuthorizationWithContext(arg0 context.Context, arg1 *configservice.PutAggregationAuthorizationInput, arg2 ...request.Option) (*configservice.PutAggregationAuthorizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutAggregationAuthorizationWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutAggregationAuthorizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutAggregationAuthorizationWithContext indicates an expected call of PutAggregationAuthorizationWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutAggregationAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutAggregationAuthorizationWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutAggregationAuthorizationWithContext), varargs...) +} + +// PutConfigRule mocks base method +func (m *MockConfigServiceAPI) PutConfigRule(arg0 *configservice.PutConfigRuleInput) (*configservice.PutConfigRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutConfigRule", arg0) + ret0, _ := ret[0].(*configservice.PutConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutConfigRule indicates an expected call of PutConfigRule +func (mr *MockConfigServiceAPIMockRecorder) PutConfigRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigRule", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigRule), arg0) +} + +// PutConfigRuleRequest mocks base method +func (m *MockConfigServiceAPI) PutConfigRuleRequest(arg0 *configservice.PutConfigRuleInput) (*request.Request, *configservice.PutConfigRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutConfigRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutConfigRuleOutput) + return ret0, ret1 +} + +// PutConfigRuleRequest indicates an expected call of PutConfigRuleRequest +func (mr *MockConfigServiceAPIMockRecorder) PutConfigRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigRuleRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigRuleRequest), arg0) +} + +// PutConfigRuleWithContext mocks base method +func (m *MockConfigServiceAPI) PutConfigRuleWithContext(arg0 context.Context, arg1 *configservice.PutConfigRuleInput, arg2 ...request.Option) (*configservice.PutConfigRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutConfigRuleWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutConfigRuleWithContext indicates an expected call of PutConfigRuleWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutConfigRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigRuleWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigRuleWithContext), varargs...) +} + +// PutConfigurationAggregator mocks base method +func (m *MockConfigServiceAPI) PutConfigurationAggregator(arg0 *configservice.PutConfigurationAggregatorInput) (*configservice.PutConfigurationAggregatorOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutConfigurationAggregator", arg0) + ret0, _ := ret[0].(*configservice.PutConfigurationAggregatorOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutConfigurationAggregator indicates an expected call of PutConfigurationAggregator +func (mr *MockConfigServiceAPIMockRecorder) PutConfigurationAggregator(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigurationAggregator", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigurationAggregator), arg0) +} + +// PutConfigurationAggregatorRequest mocks base method +func (m *MockConfigServiceAPI) PutConfigurationAggregatorRequest(arg0 *configservice.PutConfigurationAggregatorInput) (*request.Request, *configservice.PutConfigurationAggregatorOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutConfigurationAggregatorRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutConfigurationAggregatorOutput) + return ret0, ret1 +} + +// PutConfigurationAggregatorRequest indicates an expected call of PutConfigurationAggregatorRequest +func (mr *MockConfigServiceAPIMockRecorder) PutConfigurationAggregatorRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigurationAggregatorRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigurationAggregatorRequest), arg0) +} + +// PutConfigurationAggregatorWithContext mocks base method +func (m *MockConfigServiceAPI) PutConfigurationAggregatorWithContext(arg0 context.Context, arg1 *configservice.PutConfigurationAggregatorInput, arg2 ...request.Option) (*configservice.PutConfigurationAggregatorOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutConfigurationAggregatorWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutConfigurationAggregatorOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutConfigurationAggregatorWithContext indicates an expected call of PutConfigurationAggregatorWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutConfigurationAggregatorWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigurationAggregatorWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigurationAggregatorWithContext), varargs...) +} + +// PutConfigurationRecorder mocks base method +func (m *MockConfigServiceAPI) PutConfigurationRecorder(arg0 *configservice.PutConfigurationRecorderInput) (*configservice.PutConfigurationRecorderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutConfigurationRecorder", arg0) + ret0, _ := ret[0].(*configservice.PutConfigurationRecorderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutConfigurationRecorder indicates an expected call of PutConfigurationRecorder +func (mr *MockConfigServiceAPIMockRecorder) PutConfigurationRecorder(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigurationRecorder", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigurationRecorder), arg0) +} + +// PutConfigurationRecorderRequest mocks base method +func (m *MockConfigServiceAPI) PutConfigurationRecorderRequest(arg0 *configservice.PutConfigurationRecorderInput) (*request.Request, *configservice.PutConfigurationRecorderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutConfigurationRecorderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutConfigurationRecorderOutput) + return ret0, ret1 +} + +// PutConfigurationRecorderRequest indicates an expected call of PutConfigurationRecorderRequest +func (mr *MockConfigServiceAPIMockRecorder) PutConfigurationRecorderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigurationRecorderRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigurationRecorderRequest), arg0) +} + +// PutConfigurationRecorderWithContext mocks base method +func (m *MockConfigServiceAPI) PutConfigurationRecorderWithContext(arg0 context.Context, arg1 *configservice.PutConfigurationRecorderInput, arg2 ...request.Option) (*configservice.PutConfigurationRecorderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutConfigurationRecorderWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutConfigurationRecorderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutConfigurationRecorderWithContext indicates an expected call of PutConfigurationRecorderWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutConfigurationRecorderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConfigurationRecorderWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConfigurationRecorderWithContext), varargs...) +} + +// PutConformancePack mocks base method +func (m *MockConfigServiceAPI) PutConformancePack(arg0 *configservice.PutConformancePackInput) (*configservice.PutConformancePackOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutConformancePack", arg0) + ret0, _ := ret[0].(*configservice.PutConformancePackOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutConformancePack indicates an expected call of PutConformancePack +func (mr *MockConfigServiceAPIMockRecorder) PutConformancePack(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConformancePack", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConformancePack), arg0) +} + +// PutConformancePackRequest mocks base method +func (m *MockConfigServiceAPI) PutConformancePackRequest(arg0 *configservice.PutConformancePackInput) (*request.Request, *configservice.PutConformancePackOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutConformancePackRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutConformancePackOutput) + return ret0, ret1 +} + +// PutConformancePackRequest indicates an expected call of PutConformancePackRequest +func (mr *MockConfigServiceAPIMockRecorder) PutConformancePackRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConformancePackRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConformancePackRequest), arg0) +} + +// PutConformancePackWithContext mocks base method +func (m *MockConfigServiceAPI) PutConformancePackWithContext(arg0 context.Context, arg1 *configservice.PutConformancePackInput, arg2 ...request.Option) (*configservice.PutConformancePackOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutConformancePackWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutConformancePackOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutConformancePackWithContext indicates an expected call of PutConformancePackWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutConformancePackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConformancePackWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutConformancePackWithContext), varargs...) +} + +// PutDeliveryChannel mocks base method +func (m *MockConfigServiceAPI) PutDeliveryChannel(arg0 *configservice.PutDeliveryChannelInput) (*configservice.PutDeliveryChannelOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutDeliveryChannel", arg0) + ret0, _ := ret[0].(*configservice.PutDeliveryChannelOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutDeliveryChannel indicates an expected call of PutDeliveryChannel +func (mr *MockConfigServiceAPIMockRecorder) PutDeliveryChannel(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutDeliveryChannel", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutDeliveryChannel), arg0) +} + +// PutDeliveryChannelRequest mocks base method +func (m *MockConfigServiceAPI) PutDeliveryChannelRequest(arg0 *configservice.PutDeliveryChannelInput) (*request.Request, *configservice.PutDeliveryChannelOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutDeliveryChannelRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutDeliveryChannelOutput) + return ret0, ret1 +} + +// PutDeliveryChannelRequest indicates an expected call of PutDeliveryChannelRequest +func (mr *MockConfigServiceAPIMockRecorder) PutDeliveryChannelRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutDeliveryChannelRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutDeliveryChannelRequest), arg0) +} + +// PutDeliveryChannelWithContext mocks base method +func (m *MockConfigServiceAPI) PutDeliveryChannelWithContext(arg0 context.Context, arg1 *configservice.PutDeliveryChannelInput, arg2 ...request.Option) (*configservice.PutDeliveryChannelOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutDeliveryChannelWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutDeliveryChannelOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutDeliveryChannelWithContext indicates an expected call of PutDeliveryChannelWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutDeliveryChannelWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutDeliveryChannelWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutDeliveryChannelWithContext), varargs...) +} + +// PutEvaluations mocks base method +func (m *MockConfigServiceAPI) PutEvaluations(arg0 *configservice.PutEvaluationsInput) (*configservice.PutEvaluationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutEvaluations", arg0) + ret0, _ := ret[0].(*configservice.PutEvaluationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutEvaluations indicates an expected call of PutEvaluations +func (mr *MockConfigServiceAPIMockRecorder) PutEvaluations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEvaluations", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutEvaluations), arg0) +} + +// PutEvaluationsRequest mocks base method +func (m *MockConfigServiceAPI) PutEvaluationsRequest(arg0 *configservice.PutEvaluationsInput) (*request.Request, *configservice.PutEvaluationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutEvaluationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutEvaluationsOutput) + return ret0, ret1 +} + +// PutEvaluationsRequest indicates an expected call of PutEvaluationsRequest +func (mr *MockConfigServiceAPIMockRecorder) PutEvaluationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEvaluationsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutEvaluationsRequest), arg0) +} + +// PutEvaluationsWithContext mocks base method +func (m *MockConfigServiceAPI) PutEvaluationsWithContext(arg0 context.Context, arg1 *configservice.PutEvaluationsInput, arg2 ...request.Option) (*configservice.PutEvaluationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutEvaluationsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutEvaluationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutEvaluationsWithContext indicates an expected call of PutEvaluationsWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutEvaluationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEvaluationsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutEvaluationsWithContext), varargs...) +} + +// PutOrganizationConfigRule mocks base method +func (m *MockConfigServiceAPI) PutOrganizationConfigRule(arg0 *configservice.PutOrganizationConfigRuleInput) (*configservice.PutOrganizationConfigRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutOrganizationConfigRule", arg0) + ret0, _ := ret[0].(*configservice.PutOrganizationConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutOrganizationConfigRule indicates an expected call of PutOrganizationConfigRule +func (mr *MockConfigServiceAPIMockRecorder) PutOrganizationConfigRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOrganizationConfigRule", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutOrganizationConfigRule), arg0) +} + +// PutOrganizationConfigRuleRequest mocks base method +func (m *MockConfigServiceAPI) PutOrganizationConfigRuleRequest(arg0 *configservice.PutOrganizationConfigRuleInput) (*request.Request, *configservice.PutOrganizationConfigRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutOrganizationConfigRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutOrganizationConfigRuleOutput) + return ret0, ret1 +} + +// PutOrganizationConfigRuleRequest indicates an expected call of PutOrganizationConfigRuleRequest +func (mr *MockConfigServiceAPIMockRecorder) PutOrganizationConfigRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOrganizationConfigRuleRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutOrganizationConfigRuleRequest), arg0) +} + +// PutOrganizationConfigRuleWithContext mocks base method +func (m *MockConfigServiceAPI) PutOrganizationConfigRuleWithContext(arg0 context.Context, arg1 *configservice.PutOrganizationConfigRuleInput, arg2 ...request.Option) (*configservice.PutOrganizationConfigRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutOrganizationConfigRuleWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutOrganizationConfigRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutOrganizationConfigRuleWithContext indicates an expected call of PutOrganizationConfigRuleWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutOrganizationConfigRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOrganizationConfigRuleWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutOrganizationConfigRuleWithContext), varargs...) +} + +// PutOrganizationConformancePack mocks base method +func (m *MockConfigServiceAPI) PutOrganizationConformancePack(arg0 *configservice.PutOrganizationConformancePackInput) (*configservice.PutOrganizationConformancePackOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutOrganizationConformancePack", arg0) + ret0, _ := ret[0].(*configservice.PutOrganizationConformancePackOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutOrganizationConformancePack indicates an expected call of PutOrganizationConformancePack +func (mr *MockConfigServiceAPIMockRecorder) PutOrganizationConformancePack(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOrganizationConformancePack", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutOrganizationConformancePack), arg0) +} + +// PutOrganizationConformancePackRequest mocks base method +func (m *MockConfigServiceAPI) PutOrganizationConformancePackRequest(arg0 *configservice.PutOrganizationConformancePackInput) (*request.Request, *configservice.PutOrganizationConformancePackOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutOrganizationConformancePackRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutOrganizationConformancePackOutput) + return ret0, ret1 +} + +// PutOrganizationConformancePackRequest indicates an expected call of PutOrganizationConformancePackRequest +func (mr *MockConfigServiceAPIMockRecorder) PutOrganizationConformancePackRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOrganizationConformancePackRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutOrganizationConformancePackRequest), arg0) +} + +// PutOrganizationConformancePackWithContext mocks base method +func (m *MockConfigServiceAPI) PutOrganizationConformancePackWithContext(arg0 context.Context, arg1 *configservice.PutOrganizationConformancePackInput, arg2 ...request.Option) (*configservice.PutOrganizationConformancePackOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutOrganizationConformancePackWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutOrganizationConformancePackOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutOrganizationConformancePackWithContext indicates an expected call of PutOrganizationConformancePackWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutOrganizationConformancePackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutOrganizationConformancePackWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutOrganizationConformancePackWithContext), varargs...) +} + +// PutRemediationConfigurations mocks base method +func (m *MockConfigServiceAPI) PutRemediationConfigurations(arg0 *configservice.PutRemediationConfigurationsInput) (*configservice.PutRemediationConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRemediationConfigurations", arg0) + ret0, _ := ret[0].(*configservice.PutRemediationConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRemediationConfigurations indicates an expected call of PutRemediationConfigurations +func (mr *MockConfigServiceAPIMockRecorder) PutRemediationConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRemediationConfigurations", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRemediationConfigurations), arg0) +} + +// PutRemediationConfigurationsRequest mocks base method +func (m *MockConfigServiceAPI) PutRemediationConfigurationsRequest(arg0 *configservice.PutRemediationConfigurationsInput) (*request.Request, *configservice.PutRemediationConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRemediationConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutRemediationConfigurationsOutput) + return ret0, ret1 +} + +// PutRemediationConfigurationsRequest indicates an expected call of PutRemediationConfigurationsRequest +func (mr *MockConfigServiceAPIMockRecorder) PutRemediationConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRemediationConfigurationsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRemediationConfigurationsRequest), arg0) +} + +// PutRemediationConfigurationsWithContext mocks base method +func (m *MockConfigServiceAPI) PutRemediationConfigurationsWithContext(arg0 context.Context, arg1 *configservice.PutRemediationConfigurationsInput, arg2 ...request.Option) (*configservice.PutRemediationConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutRemediationConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutRemediationConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRemediationConfigurationsWithContext indicates an expected call of PutRemediationConfigurationsWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutRemediationConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRemediationConfigurationsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRemediationConfigurationsWithContext), varargs...) +} + +// PutRemediationExceptions mocks base method +func (m *MockConfigServiceAPI) PutRemediationExceptions(arg0 *configservice.PutRemediationExceptionsInput) (*configservice.PutRemediationExceptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRemediationExceptions", arg0) + ret0, _ := ret[0].(*configservice.PutRemediationExceptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRemediationExceptions indicates an expected call of PutRemediationExceptions +func (mr *MockConfigServiceAPIMockRecorder) PutRemediationExceptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRemediationExceptions", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRemediationExceptions), arg0) +} + +// PutRemediationExceptionsRequest mocks base method +func (m *MockConfigServiceAPI) PutRemediationExceptionsRequest(arg0 *configservice.PutRemediationExceptionsInput) (*request.Request, *configservice.PutRemediationExceptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRemediationExceptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutRemediationExceptionsOutput) + return ret0, ret1 +} + +// PutRemediationExceptionsRequest indicates an expected call of PutRemediationExceptionsRequest +func (mr *MockConfigServiceAPIMockRecorder) PutRemediationExceptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRemediationExceptionsRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRemediationExceptionsRequest), arg0) +} + +// PutRemediationExceptionsWithContext mocks base method +func (m *MockConfigServiceAPI) PutRemediationExceptionsWithContext(arg0 context.Context, arg1 *configservice.PutRemediationExceptionsInput, arg2 ...request.Option) (*configservice.PutRemediationExceptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutRemediationExceptionsWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutRemediationExceptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRemediationExceptionsWithContext indicates an expected call of PutRemediationExceptionsWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutRemediationExceptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRemediationExceptionsWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRemediationExceptionsWithContext), varargs...) +} + +// PutResourceConfig mocks base method +func (m *MockConfigServiceAPI) PutResourceConfig(arg0 *configservice.PutResourceConfigInput) (*configservice.PutResourceConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutResourceConfig", arg0) + ret0, _ := ret[0].(*configservice.PutResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutResourceConfig indicates an expected call of PutResourceConfig +func (mr *MockConfigServiceAPIMockRecorder) PutResourceConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourceConfig", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutResourceConfig), arg0) +} + +// PutResourceConfigRequest mocks base method +func (m *MockConfigServiceAPI) PutResourceConfigRequest(arg0 *configservice.PutResourceConfigInput) (*request.Request, *configservice.PutResourceConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutResourceConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutResourceConfigOutput) + return ret0, ret1 +} + +// PutResourceConfigRequest indicates an expected call of PutResourceConfigRequest +func (mr *MockConfigServiceAPIMockRecorder) PutResourceConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourceConfigRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutResourceConfigRequest), arg0) +} + +// PutResourceConfigWithContext mocks base method +func (m *MockConfigServiceAPI) PutResourceConfigWithContext(arg0 context.Context, arg1 *configservice.PutResourceConfigInput, arg2 ...request.Option) (*configservice.PutResourceConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutResourceConfigWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutResourceConfigWithContext indicates an expected call of PutResourceConfigWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutResourceConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourceConfigWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutResourceConfigWithContext), varargs...) +} + +// PutRetentionConfiguration mocks base method +func (m *MockConfigServiceAPI) PutRetentionConfiguration(arg0 *configservice.PutRetentionConfigurationInput) (*configservice.PutRetentionConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRetentionConfiguration", arg0) + ret0, _ := ret[0].(*configservice.PutRetentionConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRetentionConfiguration indicates an expected call of PutRetentionConfiguration +func (mr *MockConfigServiceAPIMockRecorder) PutRetentionConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRetentionConfiguration", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRetentionConfiguration), arg0) +} + +// PutRetentionConfigurationRequest mocks base method +func (m *MockConfigServiceAPI) PutRetentionConfigurationRequest(arg0 *configservice.PutRetentionConfigurationInput) (*request.Request, *configservice.PutRetentionConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRetentionConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.PutRetentionConfigurationOutput) + return ret0, ret1 +} + +// PutRetentionConfigurationRequest indicates an expected call of PutRetentionConfigurationRequest +func (mr *MockConfigServiceAPIMockRecorder) PutRetentionConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRetentionConfigurationRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRetentionConfigurationRequest), arg0) +} + +// PutRetentionConfigurationWithContext mocks base method +func (m *MockConfigServiceAPI) PutRetentionConfigurationWithContext(arg0 context.Context, arg1 *configservice.PutRetentionConfigurationInput, arg2 ...request.Option) (*configservice.PutRetentionConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutRetentionConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*configservice.PutRetentionConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRetentionConfigurationWithContext indicates an expected call of PutRetentionConfigurationWithContext +func (mr *MockConfigServiceAPIMockRecorder) PutRetentionConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRetentionConfigurationWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).PutRetentionConfigurationWithContext), varargs...) +} + +// SelectAggregateResourceConfig mocks base method +func (m *MockConfigServiceAPI) SelectAggregateResourceConfig(arg0 *configservice.SelectAggregateResourceConfigInput) (*configservice.SelectAggregateResourceConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SelectAggregateResourceConfig", arg0) + ret0, _ := ret[0].(*configservice.SelectAggregateResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SelectAggregateResourceConfig indicates an expected call of SelectAggregateResourceConfig +func (mr *MockConfigServiceAPIMockRecorder) SelectAggregateResourceConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAggregateResourceConfig", reflect.TypeOf((*MockConfigServiceAPI)(nil).SelectAggregateResourceConfig), arg0) +} + +// SelectAggregateResourceConfigPages mocks base method +func (m *MockConfigServiceAPI) SelectAggregateResourceConfigPages(arg0 *configservice.SelectAggregateResourceConfigInput, arg1 func(*configservice.SelectAggregateResourceConfigOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SelectAggregateResourceConfigPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SelectAggregateResourceConfigPages indicates an expected call of SelectAggregateResourceConfigPages +func (mr *MockConfigServiceAPIMockRecorder) SelectAggregateResourceConfigPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAggregateResourceConfigPages", reflect.TypeOf((*MockConfigServiceAPI)(nil).SelectAggregateResourceConfigPages), arg0, arg1) +} + +// SelectAggregateResourceConfigPagesWithContext mocks base method +func (m *MockConfigServiceAPI) SelectAggregateResourceConfigPagesWithContext(arg0 context.Context, arg1 *configservice.SelectAggregateResourceConfigInput, arg2 func(*configservice.SelectAggregateResourceConfigOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SelectAggregateResourceConfigPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SelectAggregateResourceConfigPagesWithContext indicates an expected call of SelectAggregateResourceConfigPagesWithContext +func (mr *MockConfigServiceAPIMockRecorder) SelectAggregateResourceConfigPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAggregateResourceConfigPagesWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).SelectAggregateResourceConfigPagesWithContext), varargs...) +} + +// SelectAggregateResourceConfigRequest mocks base method +func (m *MockConfigServiceAPI) SelectAggregateResourceConfigRequest(arg0 *configservice.SelectAggregateResourceConfigInput) (*request.Request, *configservice.SelectAggregateResourceConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SelectAggregateResourceConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.SelectAggregateResourceConfigOutput) + return ret0, ret1 +} + +// SelectAggregateResourceConfigRequest indicates an expected call of SelectAggregateResourceConfigRequest +func (mr *MockConfigServiceAPIMockRecorder) SelectAggregateResourceConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAggregateResourceConfigRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).SelectAggregateResourceConfigRequest), arg0) +} + +// SelectAggregateResourceConfigWithContext mocks base method +func (m *MockConfigServiceAPI) SelectAggregateResourceConfigWithContext(arg0 context.Context, arg1 *configservice.SelectAggregateResourceConfigInput, arg2 ...request.Option) (*configservice.SelectAggregateResourceConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SelectAggregateResourceConfigWithContext", varargs...) + ret0, _ := ret[0].(*configservice.SelectAggregateResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SelectAggregateResourceConfigWithContext indicates an expected call of SelectAggregateResourceConfigWithContext +func (mr *MockConfigServiceAPIMockRecorder) SelectAggregateResourceConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectAggregateResourceConfigWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).SelectAggregateResourceConfigWithContext), varargs...) +} + +// SelectResourceConfig mocks base method +func (m *MockConfigServiceAPI) SelectResourceConfig(arg0 *configservice.SelectResourceConfigInput) (*configservice.SelectResourceConfigOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SelectResourceConfig", arg0) + ret0, _ := ret[0].(*configservice.SelectResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SelectResourceConfig indicates an expected call of SelectResourceConfig +func (mr *MockConfigServiceAPIMockRecorder) SelectResourceConfig(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectResourceConfig", reflect.TypeOf((*MockConfigServiceAPI)(nil).SelectResourceConfig), arg0) +} + +// SelectResourceConfigRequest mocks base method +func (m *MockConfigServiceAPI) SelectResourceConfigRequest(arg0 *configservice.SelectResourceConfigInput) (*request.Request, *configservice.SelectResourceConfigOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SelectResourceConfigRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.SelectResourceConfigOutput) + return ret0, ret1 +} + +// SelectResourceConfigRequest indicates an expected call of SelectResourceConfigRequest +func (mr *MockConfigServiceAPIMockRecorder) SelectResourceConfigRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectResourceConfigRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).SelectResourceConfigRequest), arg0) +} + +// SelectResourceConfigWithContext mocks base method +func (m *MockConfigServiceAPI) SelectResourceConfigWithContext(arg0 context.Context, arg1 *configservice.SelectResourceConfigInput, arg2 ...request.Option) (*configservice.SelectResourceConfigOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SelectResourceConfigWithContext", varargs...) + ret0, _ := ret[0].(*configservice.SelectResourceConfigOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SelectResourceConfigWithContext indicates an expected call of SelectResourceConfigWithContext +func (mr *MockConfigServiceAPIMockRecorder) SelectResourceConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectResourceConfigWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).SelectResourceConfigWithContext), varargs...) +} + +// StartConfigRulesEvaluation mocks base method +func (m *MockConfigServiceAPI) StartConfigRulesEvaluation(arg0 *configservice.StartConfigRulesEvaluationInput) (*configservice.StartConfigRulesEvaluationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartConfigRulesEvaluation", arg0) + ret0, _ := ret[0].(*configservice.StartConfigRulesEvaluationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartConfigRulesEvaluation indicates an expected call of StartConfigRulesEvaluation +func (mr *MockConfigServiceAPIMockRecorder) StartConfigRulesEvaluation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartConfigRulesEvaluation", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartConfigRulesEvaluation), arg0) +} + +// StartConfigRulesEvaluationRequest mocks base method +func (m *MockConfigServiceAPI) StartConfigRulesEvaluationRequest(arg0 *configservice.StartConfigRulesEvaluationInput) (*request.Request, *configservice.StartConfigRulesEvaluationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartConfigRulesEvaluationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.StartConfigRulesEvaluationOutput) + return ret0, ret1 +} + +// StartConfigRulesEvaluationRequest indicates an expected call of StartConfigRulesEvaluationRequest +func (mr *MockConfigServiceAPIMockRecorder) StartConfigRulesEvaluationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartConfigRulesEvaluationRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartConfigRulesEvaluationRequest), arg0) +} + +// StartConfigRulesEvaluationWithContext mocks base method +func (m *MockConfigServiceAPI) StartConfigRulesEvaluationWithContext(arg0 context.Context, arg1 *configservice.StartConfigRulesEvaluationInput, arg2 ...request.Option) (*configservice.StartConfigRulesEvaluationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartConfigRulesEvaluationWithContext", varargs...) + ret0, _ := ret[0].(*configservice.StartConfigRulesEvaluationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartConfigRulesEvaluationWithContext indicates an expected call of StartConfigRulesEvaluationWithContext +func (mr *MockConfigServiceAPIMockRecorder) StartConfigRulesEvaluationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartConfigRulesEvaluationWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartConfigRulesEvaluationWithContext), varargs...) +} + +// StartConfigurationRecorder mocks base method +func (m *MockConfigServiceAPI) StartConfigurationRecorder(arg0 *configservice.StartConfigurationRecorderInput) (*configservice.StartConfigurationRecorderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartConfigurationRecorder", arg0) + ret0, _ := ret[0].(*configservice.StartConfigurationRecorderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartConfigurationRecorder indicates an expected call of StartConfigurationRecorder +func (mr *MockConfigServiceAPIMockRecorder) StartConfigurationRecorder(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartConfigurationRecorder", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartConfigurationRecorder), arg0) +} + +// StartConfigurationRecorderRequest mocks base method +func (m *MockConfigServiceAPI) StartConfigurationRecorderRequest(arg0 *configservice.StartConfigurationRecorderInput) (*request.Request, *configservice.StartConfigurationRecorderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartConfigurationRecorderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.StartConfigurationRecorderOutput) + return ret0, ret1 +} + +// StartConfigurationRecorderRequest indicates an expected call of StartConfigurationRecorderRequest +func (mr *MockConfigServiceAPIMockRecorder) StartConfigurationRecorderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartConfigurationRecorderRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartConfigurationRecorderRequest), arg0) +} + +// StartConfigurationRecorderWithContext mocks base method +func (m *MockConfigServiceAPI) StartConfigurationRecorderWithContext(arg0 context.Context, arg1 *configservice.StartConfigurationRecorderInput, arg2 ...request.Option) (*configservice.StartConfigurationRecorderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartConfigurationRecorderWithContext", varargs...) + ret0, _ := ret[0].(*configservice.StartConfigurationRecorderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartConfigurationRecorderWithContext indicates an expected call of StartConfigurationRecorderWithContext +func (mr *MockConfigServiceAPIMockRecorder) StartConfigurationRecorderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartConfigurationRecorderWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartConfigurationRecorderWithContext), varargs...) +} + +// StartRemediationExecution mocks base method +func (m *MockConfigServiceAPI) StartRemediationExecution(arg0 *configservice.StartRemediationExecutionInput) (*configservice.StartRemediationExecutionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartRemediationExecution", arg0) + ret0, _ := ret[0].(*configservice.StartRemediationExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartRemediationExecution indicates an expected call of StartRemediationExecution +func (mr *MockConfigServiceAPIMockRecorder) StartRemediationExecution(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartRemediationExecution", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartRemediationExecution), arg0) +} + +// StartRemediationExecutionRequest mocks base method +func (m *MockConfigServiceAPI) StartRemediationExecutionRequest(arg0 *configservice.StartRemediationExecutionInput) (*request.Request, *configservice.StartRemediationExecutionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartRemediationExecutionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.StartRemediationExecutionOutput) + return ret0, ret1 +} + +// StartRemediationExecutionRequest indicates an expected call of StartRemediationExecutionRequest +func (mr *MockConfigServiceAPIMockRecorder) StartRemediationExecutionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartRemediationExecutionRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartRemediationExecutionRequest), arg0) +} + +// StartRemediationExecutionWithContext mocks base method +func (m *MockConfigServiceAPI) StartRemediationExecutionWithContext(arg0 context.Context, arg1 *configservice.StartRemediationExecutionInput, arg2 ...request.Option) (*configservice.StartRemediationExecutionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartRemediationExecutionWithContext", varargs...) + ret0, _ := ret[0].(*configservice.StartRemediationExecutionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartRemediationExecutionWithContext indicates an expected call of StartRemediationExecutionWithContext +func (mr *MockConfigServiceAPIMockRecorder) StartRemediationExecutionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartRemediationExecutionWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).StartRemediationExecutionWithContext), varargs...) +} + +// StopConfigurationRecorder mocks base method +func (m *MockConfigServiceAPI) StopConfigurationRecorder(arg0 *configservice.StopConfigurationRecorderInput) (*configservice.StopConfigurationRecorderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopConfigurationRecorder", arg0) + ret0, _ := ret[0].(*configservice.StopConfigurationRecorderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopConfigurationRecorder indicates an expected call of StopConfigurationRecorder +func (mr *MockConfigServiceAPIMockRecorder) StopConfigurationRecorder(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopConfigurationRecorder", reflect.TypeOf((*MockConfigServiceAPI)(nil).StopConfigurationRecorder), arg0) +} + +// StopConfigurationRecorderRequest mocks base method +func (m *MockConfigServiceAPI) StopConfigurationRecorderRequest(arg0 *configservice.StopConfigurationRecorderInput) (*request.Request, *configservice.StopConfigurationRecorderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopConfigurationRecorderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.StopConfigurationRecorderOutput) + return ret0, ret1 +} + +// StopConfigurationRecorderRequest indicates an expected call of StopConfigurationRecorderRequest +func (mr *MockConfigServiceAPIMockRecorder) StopConfigurationRecorderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopConfigurationRecorderRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).StopConfigurationRecorderRequest), arg0) +} + +// StopConfigurationRecorderWithContext mocks base method +func (m *MockConfigServiceAPI) StopConfigurationRecorderWithContext(arg0 context.Context, arg1 *configservice.StopConfigurationRecorderInput, arg2 ...request.Option) (*configservice.StopConfigurationRecorderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StopConfigurationRecorderWithContext", varargs...) + ret0, _ := ret[0].(*configservice.StopConfigurationRecorderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopConfigurationRecorderWithContext indicates an expected call of StopConfigurationRecorderWithContext +func (mr *MockConfigServiceAPIMockRecorder) StopConfigurationRecorderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopConfigurationRecorderWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).StopConfigurationRecorderWithContext), varargs...) +} + +// TagResource mocks base method +func (m *MockConfigServiceAPI) TagResource(arg0 *configservice.TagResourceInput) (*configservice.TagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResource", arg0) + ret0, _ := ret[0].(*configservice.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResource indicates an expected call of TagResource +func (mr *MockConfigServiceAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockConfigServiceAPI)(nil).TagResource), arg0) +} + +// TagResourceRequest mocks base method +func (m *MockConfigServiceAPI) TagResourceRequest(arg0 *configservice.TagResourceInput) (*request.Request, *configservice.TagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.TagResourceOutput) + return ret0, ret1 +} + +// TagResourceRequest indicates an expected call of TagResourceRequest +func (mr *MockConfigServiceAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).TagResourceRequest), arg0) +} + +// TagResourceWithContext mocks base method +func (m *MockConfigServiceAPI) TagResourceWithContext(arg0 context.Context, arg1 *configservice.TagResourceInput, arg2 ...request.Option) (*configservice.TagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) + ret0, _ := ret[0].(*configservice.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResourceWithContext indicates an expected call of TagResourceWithContext +func (mr *MockConfigServiceAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).TagResourceWithContext), varargs...) +} + +// UntagResource mocks base method +func (m *MockConfigServiceAPI) UntagResource(arg0 *configservice.UntagResourceInput) (*configservice.UntagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResource", arg0) + ret0, _ := ret[0].(*configservice.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResource indicates an expected call of UntagResource +func (mr *MockConfigServiceAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockConfigServiceAPI)(nil).UntagResource), arg0) +} + +// UntagResourceRequest mocks base method +func (m *MockConfigServiceAPI) UntagResourceRequest(arg0 *configservice.UntagResourceInput) (*request.Request, *configservice.UntagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*configservice.UntagResourceOutput) + return ret0, ret1 +} + +// UntagResourceRequest indicates an expected call of UntagResourceRequest +func (mr *MockConfigServiceAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockConfigServiceAPI)(nil).UntagResourceRequest), arg0) +} + +// UntagResourceWithContext mocks base method +func (m *MockConfigServiceAPI) UntagResourceWithContext(arg0 context.Context, arg1 *configservice.UntagResourceInput, arg2 ...request.Option) (*configservice.UntagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) + ret0, _ := ret[0].(*configservice.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResourceWithContext indicates an expected call of UntagResourceWithContext +func (mr *MockConfigServiceAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockConfigServiceAPI)(nil).UntagResourceWithContext), varargs...) +} diff --git a/pkg/mocks/mock_cloudtrail.go b/pkg/mocks/mock_cloudtrail.go new file mode 100644 index 0000000..77628b5 --- /dev/null +++ b/pkg/mocks/mock_cloudtrail.go @@ -0,0 +1,1068 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/cloudtrail/cloudtrailiface (interfaces: CloudTrailAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + cloudtrail "github.com/aws/aws-sdk-go/service/cloudtrail" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockCloudTrailAPI is a mock of CloudTrailAPI interface +type MockCloudTrailAPI struct { + ctrl *gomock.Controller + recorder *MockCloudTrailAPIMockRecorder +} + +// MockCloudTrailAPIMockRecorder is the mock recorder for MockCloudTrailAPI +type MockCloudTrailAPIMockRecorder struct { + mock *MockCloudTrailAPI +} + +// NewMockCloudTrailAPI creates a new mock instance +func NewMockCloudTrailAPI(ctrl *gomock.Controller) *MockCloudTrailAPI { + mock := &MockCloudTrailAPI{ctrl: ctrl} + mock.recorder = &MockCloudTrailAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockCloudTrailAPI) EXPECT() *MockCloudTrailAPIMockRecorder { + return m.recorder +} + +// AddTags mocks base method +func (m *MockCloudTrailAPI) AddTags(arg0 *cloudtrail.AddTagsInput) (*cloudtrail.AddTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddTags", arg0) + ret0, _ := ret[0].(*cloudtrail.AddTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddTags indicates an expected call of AddTags +func (mr *MockCloudTrailAPIMockRecorder) AddTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockCloudTrailAPI)(nil).AddTags), arg0) +} + +// AddTagsRequest mocks base method +func (m *MockCloudTrailAPI) AddTagsRequest(arg0 *cloudtrail.AddTagsInput) (*request.Request, *cloudtrail.AddTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.AddTagsOutput) + return ret0, ret1 +} + +// AddTagsRequest indicates an expected call of AddTagsRequest +func (mr *MockCloudTrailAPIMockRecorder) AddTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).AddTagsRequest), arg0) +} + +// AddTagsWithContext mocks base method +func (m *MockCloudTrailAPI) AddTagsWithContext(arg0 context.Context, arg1 *cloudtrail.AddTagsInput, arg2 ...request.Option) (*cloudtrail.AddTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddTagsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.AddTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddTagsWithContext indicates an expected call of AddTagsWithContext +func (mr *MockCloudTrailAPIMockRecorder) AddTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).AddTagsWithContext), varargs...) +} + +// CreateTrail mocks base method +func (m *MockCloudTrailAPI) CreateTrail(arg0 *cloudtrail.CreateTrailInput) (*cloudtrail.CreateTrailOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrail", arg0) + ret0, _ := ret[0].(*cloudtrail.CreateTrailOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrail indicates an expected call of CreateTrail +func (mr *MockCloudTrailAPIMockRecorder) CreateTrail(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrail", reflect.TypeOf((*MockCloudTrailAPI)(nil).CreateTrail), arg0) +} + +// CreateTrailRequest mocks base method +func (m *MockCloudTrailAPI) CreateTrailRequest(arg0 *cloudtrail.CreateTrailInput) (*request.Request, *cloudtrail.CreateTrailOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrailRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.CreateTrailOutput) + return ret0, ret1 +} + +// CreateTrailRequest indicates an expected call of CreateTrailRequest +func (mr *MockCloudTrailAPIMockRecorder) CreateTrailRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrailRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).CreateTrailRequest), arg0) +} + +// CreateTrailWithContext mocks base method +func (m *MockCloudTrailAPI) CreateTrailWithContext(arg0 context.Context, arg1 *cloudtrail.CreateTrailInput, arg2 ...request.Option) (*cloudtrail.CreateTrailOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTrailWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.CreateTrailOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrailWithContext indicates an expected call of CreateTrailWithContext +func (mr *MockCloudTrailAPIMockRecorder) CreateTrailWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrailWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).CreateTrailWithContext), varargs...) +} + +// DeleteTrail mocks base method +func (m *MockCloudTrailAPI) DeleteTrail(arg0 *cloudtrail.DeleteTrailInput) (*cloudtrail.DeleteTrailOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrail", arg0) + ret0, _ := ret[0].(*cloudtrail.DeleteTrailOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrail indicates an expected call of DeleteTrail +func (mr *MockCloudTrailAPIMockRecorder) DeleteTrail(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrail", reflect.TypeOf((*MockCloudTrailAPI)(nil).DeleteTrail), arg0) +} + +// DeleteTrailRequest mocks base method +func (m *MockCloudTrailAPI) DeleteTrailRequest(arg0 *cloudtrail.DeleteTrailInput) (*request.Request, *cloudtrail.DeleteTrailOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrailRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.DeleteTrailOutput) + return ret0, ret1 +} + +// DeleteTrailRequest indicates an expected call of DeleteTrailRequest +func (mr *MockCloudTrailAPIMockRecorder) DeleteTrailRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrailRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).DeleteTrailRequest), arg0) +} + +// DeleteTrailWithContext mocks base method +func (m *MockCloudTrailAPI) DeleteTrailWithContext(arg0 context.Context, arg1 *cloudtrail.DeleteTrailInput, arg2 ...request.Option) (*cloudtrail.DeleteTrailOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTrailWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.DeleteTrailOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrailWithContext indicates an expected call of DeleteTrailWithContext +func (mr *MockCloudTrailAPIMockRecorder) DeleteTrailWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrailWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).DeleteTrailWithContext), varargs...) +} + +// DescribeTrails mocks base method +func (m *MockCloudTrailAPI) DescribeTrails(arg0 *cloudtrail.DescribeTrailsInput) (*cloudtrail.DescribeTrailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrails", arg0) + ret0, _ := ret[0].(*cloudtrail.DescribeTrailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrails indicates an expected call of DescribeTrails +func (mr *MockCloudTrailAPIMockRecorder) DescribeTrails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrails", reflect.TypeOf((*MockCloudTrailAPI)(nil).DescribeTrails), arg0) +} + +// DescribeTrailsRequest mocks base method +func (m *MockCloudTrailAPI) DescribeTrailsRequest(arg0 *cloudtrail.DescribeTrailsInput) (*request.Request, *cloudtrail.DescribeTrailsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrailsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.DescribeTrailsOutput) + return ret0, ret1 +} + +// DescribeTrailsRequest indicates an expected call of DescribeTrailsRequest +func (mr *MockCloudTrailAPIMockRecorder) DescribeTrailsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrailsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).DescribeTrailsRequest), arg0) +} + +// DescribeTrailsWithContext mocks base method +func (m *MockCloudTrailAPI) DescribeTrailsWithContext(arg0 context.Context, arg1 *cloudtrail.DescribeTrailsInput, arg2 ...request.Option) (*cloudtrail.DescribeTrailsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrailsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.DescribeTrailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrailsWithContext indicates an expected call of DescribeTrailsWithContext +func (mr *MockCloudTrailAPIMockRecorder) DescribeTrailsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrailsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).DescribeTrailsWithContext), varargs...) +} + +// GetEventSelectors mocks base method +func (m *MockCloudTrailAPI) GetEventSelectors(arg0 *cloudtrail.GetEventSelectorsInput) (*cloudtrail.GetEventSelectorsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEventSelectors", arg0) + ret0, _ := ret[0].(*cloudtrail.GetEventSelectorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetEventSelectors indicates an expected call of GetEventSelectors +func (mr *MockCloudTrailAPIMockRecorder) GetEventSelectors(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventSelectors", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetEventSelectors), arg0) +} + +// GetEventSelectorsRequest mocks base method +func (m *MockCloudTrailAPI) GetEventSelectorsRequest(arg0 *cloudtrail.GetEventSelectorsInput) (*request.Request, *cloudtrail.GetEventSelectorsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEventSelectorsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.GetEventSelectorsOutput) + return ret0, ret1 +} + +// GetEventSelectorsRequest indicates an expected call of GetEventSelectorsRequest +func (mr *MockCloudTrailAPIMockRecorder) GetEventSelectorsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventSelectorsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetEventSelectorsRequest), arg0) +} + +// GetEventSelectorsWithContext mocks base method +func (m *MockCloudTrailAPI) GetEventSelectorsWithContext(arg0 context.Context, arg1 *cloudtrail.GetEventSelectorsInput, arg2 ...request.Option) (*cloudtrail.GetEventSelectorsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetEventSelectorsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.GetEventSelectorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetEventSelectorsWithContext indicates an expected call of GetEventSelectorsWithContext +func (mr *MockCloudTrailAPIMockRecorder) GetEventSelectorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventSelectorsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetEventSelectorsWithContext), varargs...) +} + +// GetInsightSelectors mocks base method +func (m *MockCloudTrailAPI) GetInsightSelectors(arg0 *cloudtrail.GetInsightSelectorsInput) (*cloudtrail.GetInsightSelectorsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInsightSelectors", arg0) + ret0, _ := ret[0].(*cloudtrail.GetInsightSelectorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInsightSelectors indicates an expected call of GetInsightSelectors +func (mr *MockCloudTrailAPIMockRecorder) GetInsightSelectors(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInsightSelectors", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetInsightSelectors), arg0) +} + +// GetInsightSelectorsRequest mocks base method +func (m *MockCloudTrailAPI) GetInsightSelectorsRequest(arg0 *cloudtrail.GetInsightSelectorsInput) (*request.Request, *cloudtrail.GetInsightSelectorsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInsightSelectorsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.GetInsightSelectorsOutput) + return ret0, ret1 +} + +// GetInsightSelectorsRequest indicates an expected call of GetInsightSelectorsRequest +func (mr *MockCloudTrailAPIMockRecorder) GetInsightSelectorsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInsightSelectorsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetInsightSelectorsRequest), arg0) +} + +// GetInsightSelectorsWithContext mocks base method +func (m *MockCloudTrailAPI) GetInsightSelectorsWithContext(arg0 context.Context, arg1 *cloudtrail.GetInsightSelectorsInput, arg2 ...request.Option) (*cloudtrail.GetInsightSelectorsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetInsightSelectorsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.GetInsightSelectorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInsightSelectorsWithContext indicates an expected call of GetInsightSelectorsWithContext +func (mr *MockCloudTrailAPIMockRecorder) GetInsightSelectorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInsightSelectorsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetInsightSelectorsWithContext), varargs...) +} + +// GetTrail mocks base method +func (m *MockCloudTrailAPI) GetTrail(arg0 *cloudtrail.GetTrailInput) (*cloudtrail.GetTrailOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrail", arg0) + ret0, _ := ret[0].(*cloudtrail.GetTrailOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrail indicates an expected call of GetTrail +func (mr *MockCloudTrailAPIMockRecorder) GetTrail(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrail", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetTrail), arg0) +} + +// GetTrailRequest mocks base method +func (m *MockCloudTrailAPI) GetTrailRequest(arg0 *cloudtrail.GetTrailInput) (*request.Request, *cloudtrail.GetTrailOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrailRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.GetTrailOutput) + return ret0, ret1 +} + +// GetTrailRequest indicates an expected call of GetTrailRequest +func (mr *MockCloudTrailAPIMockRecorder) GetTrailRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrailRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetTrailRequest), arg0) +} + +// GetTrailStatus mocks base method +func (m *MockCloudTrailAPI) GetTrailStatus(arg0 *cloudtrail.GetTrailStatusInput) (*cloudtrail.GetTrailStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrailStatus", arg0) + ret0, _ := ret[0].(*cloudtrail.GetTrailStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrailStatus indicates an expected call of GetTrailStatus +func (mr *MockCloudTrailAPIMockRecorder) GetTrailStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrailStatus", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetTrailStatus), arg0) +} + +// GetTrailStatusRequest mocks base method +func (m *MockCloudTrailAPI) GetTrailStatusRequest(arg0 *cloudtrail.GetTrailStatusInput) (*request.Request, *cloudtrail.GetTrailStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTrailStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.GetTrailStatusOutput) + return ret0, ret1 +} + +// GetTrailStatusRequest indicates an expected call of GetTrailStatusRequest +func (mr *MockCloudTrailAPIMockRecorder) GetTrailStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrailStatusRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetTrailStatusRequest), arg0) +} + +// GetTrailStatusWithContext mocks base method +func (m *MockCloudTrailAPI) GetTrailStatusWithContext(arg0 context.Context, arg1 *cloudtrail.GetTrailStatusInput, arg2 ...request.Option) (*cloudtrail.GetTrailStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTrailStatusWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.GetTrailStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrailStatusWithContext indicates an expected call of GetTrailStatusWithContext +func (mr *MockCloudTrailAPIMockRecorder) GetTrailStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrailStatusWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetTrailStatusWithContext), varargs...) +} + +// GetTrailWithContext mocks base method +func (m *MockCloudTrailAPI) GetTrailWithContext(arg0 context.Context, arg1 *cloudtrail.GetTrailInput, arg2 ...request.Option) (*cloudtrail.GetTrailOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTrailWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.GetTrailOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTrailWithContext indicates an expected call of GetTrailWithContext +func (mr *MockCloudTrailAPIMockRecorder) GetTrailWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrailWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).GetTrailWithContext), varargs...) +} + +// ListPublicKeys mocks base method +func (m *MockCloudTrailAPI) ListPublicKeys(arg0 *cloudtrail.ListPublicKeysInput) (*cloudtrail.ListPublicKeysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPublicKeys", arg0) + ret0, _ := ret[0].(*cloudtrail.ListPublicKeysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPublicKeys indicates an expected call of ListPublicKeys +func (mr *MockCloudTrailAPIMockRecorder) ListPublicKeys(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPublicKeys", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListPublicKeys), arg0) +} + +// ListPublicKeysPages mocks base method +func (m *MockCloudTrailAPI) ListPublicKeysPages(arg0 *cloudtrail.ListPublicKeysInput, arg1 func(*cloudtrail.ListPublicKeysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPublicKeysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPublicKeysPages indicates an expected call of ListPublicKeysPages +func (mr *MockCloudTrailAPIMockRecorder) ListPublicKeysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPublicKeysPages", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListPublicKeysPages), arg0, arg1) +} + +// ListPublicKeysPagesWithContext mocks base method +func (m *MockCloudTrailAPI) ListPublicKeysPagesWithContext(arg0 context.Context, arg1 *cloudtrail.ListPublicKeysInput, arg2 func(*cloudtrail.ListPublicKeysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPublicKeysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPublicKeysPagesWithContext indicates an expected call of ListPublicKeysPagesWithContext +func (mr *MockCloudTrailAPIMockRecorder) ListPublicKeysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPublicKeysPagesWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListPublicKeysPagesWithContext), varargs...) +} + +// ListPublicKeysRequest mocks base method +func (m *MockCloudTrailAPI) ListPublicKeysRequest(arg0 *cloudtrail.ListPublicKeysInput) (*request.Request, *cloudtrail.ListPublicKeysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPublicKeysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.ListPublicKeysOutput) + return ret0, ret1 +} + +// ListPublicKeysRequest indicates an expected call of ListPublicKeysRequest +func (mr *MockCloudTrailAPIMockRecorder) ListPublicKeysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPublicKeysRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListPublicKeysRequest), arg0) +} + +// ListPublicKeysWithContext mocks base method +func (m *MockCloudTrailAPI) ListPublicKeysWithContext(arg0 context.Context, arg1 *cloudtrail.ListPublicKeysInput, arg2 ...request.Option) (*cloudtrail.ListPublicKeysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPublicKeysWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.ListPublicKeysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPublicKeysWithContext indicates an expected call of ListPublicKeysWithContext +func (mr *MockCloudTrailAPIMockRecorder) ListPublicKeysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPublicKeysWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListPublicKeysWithContext), varargs...) +} + +// ListTags mocks base method +func (m *MockCloudTrailAPI) ListTags(arg0 *cloudtrail.ListTagsInput) (*cloudtrail.ListTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTags", arg0) + ret0, _ := ret[0].(*cloudtrail.ListTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTags indicates an expected call of ListTags +func (mr *MockCloudTrailAPIMockRecorder) ListTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTags", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTags), arg0) +} + +// ListTagsPages mocks base method +func (m *MockCloudTrailAPI) ListTagsPages(arg0 *cloudtrail.ListTagsInput, arg1 func(*cloudtrail.ListTagsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTagsPages indicates an expected call of ListTagsPages +func (mr *MockCloudTrailAPIMockRecorder) ListTagsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsPages", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTagsPages), arg0, arg1) +} + +// ListTagsPagesWithContext mocks base method +func (m *MockCloudTrailAPI) ListTagsPagesWithContext(arg0 context.Context, arg1 *cloudtrail.ListTagsInput, arg2 func(*cloudtrail.ListTagsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTagsPagesWithContext indicates an expected call of ListTagsPagesWithContext +func (mr *MockCloudTrailAPIMockRecorder) ListTagsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsPagesWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTagsPagesWithContext), varargs...) +} + +// ListTagsRequest mocks base method +func (m *MockCloudTrailAPI) ListTagsRequest(arg0 *cloudtrail.ListTagsInput) (*request.Request, *cloudtrail.ListTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.ListTagsOutput) + return ret0, ret1 +} + +// ListTagsRequest indicates an expected call of ListTagsRequest +func (mr *MockCloudTrailAPIMockRecorder) ListTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTagsRequest), arg0) +} + +// ListTagsWithContext mocks base method +func (m *MockCloudTrailAPI) ListTagsWithContext(arg0 context.Context, arg1 *cloudtrail.ListTagsInput, arg2 ...request.Option) (*cloudtrail.ListTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.ListTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsWithContext indicates an expected call of ListTagsWithContext +func (mr *MockCloudTrailAPIMockRecorder) ListTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTagsWithContext), varargs...) +} + +// ListTrails mocks base method +func (m *MockCloudTrailAPI) ListTrails(arg0 *cloudtrail.ListTrailsInput) (*cloudtrail.ListTrailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrails", arg0) + ret0, _ := ret[0].(*cloudtrail.ListTrailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrails indicates an expected call of ListTrails +func (mr *MockCloudTrailAPIMockRecorder) ListTrails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrails", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTrails), arg0) +} + +// ListTrailsPages mocks base method +func (m *MockCloudTrailAPI) ListTrailsPages(arg0 *cloudtrail.ListTrailsInput, arg1 func(*cloudtrail.ListTrailsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrailsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTrailsPages indicates an expected call of ListTrailsPages +func (mr *MockCloudTrailAPIMockRecorder) ListTrailsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrailsPages", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTrailsPages), arg0, arg1) +} + +// ListTrailsPagesWithContext mocks base method +func (m *MockCloudTrailAPI) ListTrailsPagesWithContext(arg0 context.Context, arg1 *cloudtrail.ListTrailsInput, arg2 func(*cloudtrail.ListTrailsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTrailsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListTrailsPagesWithContext indicates an expected call of ListTrailsPagesWithContext +func (mr *MockCloudTrailAPIMockRecorder) ListTrailsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrailsPagesWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTrailsPagesWithContext), varargs...) +} + +// ListTrailsRequest mocks base method +func (m *MockCloudTrailAPI) ListTrailsRequest(arg0 *cloudtrail.ListTrailsInput) (*request.Request, *cloudtrail.ListTrailsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTrailsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.ListTrailsOutput) + return ret0, ret1 +} + +// ListTrailsRequest indicates an expected call of ListTrailsRequest +func (mr *MockCloudTrailAPIMockRecorder) ListTrailsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrailsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTrailsRequest), arg0) +} + +// ListTrailsWithContext mocks base method +func (m *MockCloudTrailAPI) ListTrailsWithContext(arg0 context.Context, arg1 *cloudtrail.ListTrailsInput, arg2 ...request.Option) (*cloudtrail.ListTrailsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTrailsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.ListTrailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTrailsWithContext indicates an expected call of ListTrailsWithContext +func (mr *MockCloudTrailAPIMockRecorder) ListTrailsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrailsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).ListTrailsWithContext), varargs...) +} + +// LookupEvents mocks base method +func (m *MockCloudTrailAPI) LookupEvents(arg0 *cloudtrail.LookupEventsInput) (*cloudtrail.LookupEventsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LookupEvents", arg0) + ret0, _ := ret[0].(*cloudtrail.LookupEventsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LookupEvents indicates an expected call of LookupEvents +func (mr *MockCloudTrailAPIMockRecorder) LookupEvents(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupEvents", reflect.TypeOf((*MockCloudTrailAPI)(nil).LookupEvents), arg0) +} + +// LookupEventsPages mocks base method +func (m *MockCloudTrailAPI) LookupEventsPages(arg0 *cloudtrail.LookupEventsInput, arg1 func(*cloudtrail.LookupEventsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LookupEventsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// LookupEventsPages indicates an expected call of LookupEventsPages +func (mr *MockCloudTrailAPIMockRecorder) LookupEventsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupEventsPages", reflect.TypeOf((*MockCloudTrailAPI)(nil).LookupEventsPages), arg0, arg1) +} + +// LookupEventsPagesWithContext mocks base method +func (m *MockCloudTrailAPI) LookupEventsPagesWithContext(arg0 context.Context, arg1 *cloudtrail.LookupEventsInput, arg2 func(*cloudtrail.LookupEventsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LookupEventsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// LookupEventsPagesWithContext indicates an expected call of LookupEventsPagesWithContext +func (mr *MockCloudTrailAPIMockRecorder) LookupEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupEventsPagesWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).LookupEventsPagesWithContext), varargs...) +} + +// LookupEventsRequest mocks base method +func (m *MockCloudTrailAPI) LookupEventsRequest(arg0 *cloudtrail.LookupEventsInput) (*request.Request, *cloudtrail.LookupEventsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LookupEventsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.LookupEventsOutput) + return ret0, ret1 +} + +// LookupEventsRequest indicates an expected call of LookupEventsRequest +func (mr *MockCloudTrailAPIMockRecorder) LookupEventsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupEventsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).LookupEventsRequest), arg0) +} + +// LookupEventsWithContext mocks base method +func (m *MockCloudTrailAPI) LookupEventsWithContext(arg0 context.Context, arg1 *cloudtrail.LookupEventsInput, arg2 ...request.Option) (*cloudtrail.LookupEventsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LookupEventsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.LookupEventsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LookupEventsWithContext indicates an expected call of LookupEventsWithContext +func (mr *MockCloudTrailAPIMockRecorder) LookupEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupEventsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).LookupEventsWithContext), varargs...) +} + +// PutEventSelectors mocks base method +func (m *MockCloudTrailAPI) PutEventSelectors(arg0 *cloudtrail.PutEventSelectorsInput) (*cloudtrail.PutEventSelectorsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutEventSelectors", arg0) + ret0, _ := ret[0].(*cloudtrail.PutEventSelectorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutEventSelectors indicates an expected call of PutEventSelectors +func (mr *MockCloudTrailAPIMockRecorder) PutEventSelectors(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEventSelectors", reflect.TypeOf((*MockCloudTrailAPI)(nil).PutEventSelectors), arg0) +} + +// PutEventSelectorsRequest mocks base method +func (m *MockCloudTrailAPI) PutEventSelectorsRequest(arg0 *cloudtrail.PutEventSelectorsInput) (*request.Request, *cloudtrail.PutEventSelectorsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutEventSelectorsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.PutEventSelectorsOutput) + return ret0, ret1 +} + +// PutEventSelectorsRequest indicates an expected call of PutEventSelectorsRequest +func (mr *MockCloudTrailAPIMockRecorder) PutEventSelectorsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEventSelectorsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).PutEventSelectorsRequest), arg0) +} + +// PutEventSelectorsWithContext mocks base method +func (m *MockCloudTrailAPI) PutEventSelectorsWithContext(arg0 context.Context, arg1 *cloudtrail.PutEventSelectorsInput, arg2 ...request.Option) (*cloudtrail.PutEventSelectorsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutEventSelectorsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.PutEventSelectorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutEventSelectorsWithContext indicates an expected call of PutEventSelectorsWithContext +func (mr *MockCloudTrailAPIMockRecorder) PutEventSelectorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutEventSelectorsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).PutEventSelectorsWithContext), varargs...) +} + +// PutInsightSelectors mocks base method +func (m *MockCloudTrailAPI) PutInsightSelectors(arg0 *cloudtrail.PutInsightSelectorsInput) (*cloudtrail.PutInsightSelectorsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutInsightSelectors", arg0) + ret0, _ := ret[0].(*cloudtrail.PutInsightSelectorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutInsightSelectors indicates an expected call of PutInsightSelectors +func (mr *MockCloudTrailAPIMockRecorder) PutInsightSelectors(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutInsightSelectors", reflect.TypeOf((*MockCloudTrailAPI)(nil).PutInsightSelectors), arg0) +} + +// PutInsightSelectorsRequest mocks base method +func (m *MockCloudTrailAPI) PutInsightSelectorsRequest(arg0 *cloudtrail.PutInsightSelectorsInput) (*request.Request, *cloudtrail.PutInsightSelectorsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutInsightSelectorsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.PutInsightSelectorsOutput) + return ret0, ret1 +} + +// PutInsightSelectorsRequest indicates an expected call of PutInsightSelectorsRequest +func (mr *MockCloudTrailAPIMockRecorder) PutInsightSelectorsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutInsightSelectorsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).PutInsightSelectorsRequest), arg0) +} + +// PutInsightSelectorsWithContext mocks base method +func (m *MockCloudTrailAPI) PutInsightSelectorsWithContext(arg0 context.Context, arg1 *cloudtrail.PutInsightSelectorsInput, arg2 ...request.Option) (*cloudtrail.PutInsightSelectorsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutInsightSelectorsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.PutInsightSelectorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutInsightSelectorsWithContext indicates an expected call of PutInsightSelectorsWithContext +func (mr *MockCloudTrailAPIMockRecorder) PutInsightSelectorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutInsightSelectorsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).PutInsightSelectorsWithContext), varargs...) +} + +// RemoveTags mocks base method +func (m *MockCloudTrailAPI) RemoveTags(arg0 *cloudtrail.RemoveTagsInput) (*cloudtrail.RemoveTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveTags", arg0) + ret0, _ := ret[0].(*cloudtrail.RemoveTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveTags indicates an expected call of RemoveTags +func (mr *MockCloudTrailAPIMockRecorder) RemoveTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockCloudTrailAPI)(nil).RemoveTags), arg0) +} + +// RemoveTagsRequest mocks base method +func (m *MockCloudTrailAPI) RemoveTagsRequest(arg0 *cloudtrail.RemoveTagsInput) (*request.Request, *cloudtrail.RemoveTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.RemoveTagsOutput) + return ret0, ret1 +} + +// RemoveTagsRequest indicates an expected call of RemoveTagsRequest +func (mr *MockCloudTrailAPIMockRecorder) RemoveTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).RemoveTagsRequest), arg0) +} + +// RemoveTagsWithContext mocks base method +func (m *MockCloudTrailAPI) RemoveTagsWithContext(arg0 context.Context, arg1 *cloudtrail.RemoveTagsInput, arg2 ...request.Option) (*cloudtrail.RemoveTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RemoveTagsWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.RemoveTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveTagsWithContext indicates an expected call of RemoveTagsWithContext +func (mr *MockCloudTrailAPIMockRecorder) RemoveTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).RemoveTagsWithContext), varargs...) +} + +// StartLogging mocks base method +func (m *MockCloudTrailAPI) StartLogging(arg0 *cloudtrail.StartLoggingInput) (*cloudtrail.StartLoggingOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartLogging", arg0) + ret0, _ := ret[0].(*cloudtrail.StartLoggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartLogging indicates an expected call of StartLogging +func (mr *MockCloudTrailAPIMockRecorder) StartLogging(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartLogging", reflect.TypeOf((*MockCloudTrailAPI)(nil).StartLogging), arg0) +} + +// StartLoggingRequest mocks base method +func (m *MockCloudTrailAPI) StartLoggingRequest(arg0 *cloudtrail.StartLoggingInput) (*request.Request, *cloudtrail.StartLoggingOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartLoggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.StartLoggingOutput) + return ret0, ret1 +} + +// StartLoggingRequest indicates an expected call of StartLoggingRequest +func (mr *MockCloudTrailAPIMockRecorder) StartLoggingRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartLoggingRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).StartLoggingRequest), arg0) +} + +// StartLoggingWithContext mocks base method +func (m *MockCloudTrailAPI) StartLoggingWithContext(arg0 context.Context, arg1 *cloudtrail.StartLoggingInput, arg2 ...request.Option) (*cloudtrail.StartLoggingOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartLoggingWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.StartLoggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartLoggingWithContext indicates an expected call of StartLoggingWithContext +func (mr *MockCloudTrailAPIMockRecorder) StartLoggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartLoggingWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).StartLoggingWithContext), varargs...) +} + +// StopLogging mocks base method +func (m *MockCloudTrailAPI) StopLogging(arg0 *cloudtrail.StopLoggingInput) (*cloudtrail.StopLoggingOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopLogging", arg0) + ret0, _ := ret[0].(*cloudtrail.StopLoggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopLogging indicates an expected call of StopLogging +func (mr *MockCloudTrailAPIMockRecorder) StopLogging(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopLogging", reflect.TypeOf((*MockCloudTrailAPI)(nil).StopLogging), arg0) +} + +// StopLoggingRequest mocks base method +func (m *MockCloudTrailAPI) StopLoggingRequest(arg0 *cloudtrail.StopLoggingInput) (*request.Request, *cloudtrail.StopLoggingOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopLoggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.StopLoggingOutput) + return ret0, ret1 +} + +// StopLoggingRequest indicates an expected call of StopLoggingRequest +func (mr *MockCloudTrailAPIMockRecorder) StopLoggingRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopLoggingRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).StopLoggingRequest), arg0) +} + +// StopLoggingWithContext mocks base method +func (m *MockCloudTrailAPI) StopLoggingWithContext(arg0 context.Context, arg1 *cloudtrail.StopLoggingInput, arg2 ...request.Option) (*cloudtrail.StopLoggingOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StopLoggingWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.StopLoggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopLoggingWithContext indicates an expected call of StopLoggingWithContext +func (mr *MockCloudTrailAPIMockRecorder) StopLoggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopLoggingWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).StopLoggingWithContext), varargs...) +} + +// UpdateTrail mocks base method +func (m *MockCloudTrailAPI) UpdateTrail(arg0 *cloudtrail.UpdateTrailInput) (*cloudtrail.UpdateTrailOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTrail", arg0) + ret0, _ := ret[0].(*cloudtrail.UpdateTrailOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateTrail indicates an expected call of UpdateTrail +func (mr *MockCloudTrailAPIMockRecorder) UpdateTrail(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrail", reflect.TypeOf((*MockCloudTrailAPI)(nil).UpdateTrail), arg0) +} + +// UpdateTrailRequest mocks base method +func (m *MockCloudTrailAPI) UpdateTrailRequest(arg0 *cloudtrail.UpdateTrailInput) (*request.Request, *cloudtrail.UpdateTrailOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTrailRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*cloudtrail.UpdateTrailOutput) + return ret0, ret1 +} + +// UpdateTrailRequest indicates an expected call of UpdateTrailRequest +func (mr *MockCloudTrailAPIMockRecorder) UpdateTrailRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrailRequest", reflect.TypeOf((*MockCloudTrailAPI)(nil).UpdateTrailRequest), arg0) +} + +// UpdateTrailWithContext mocks base method +func (m *MockCloudTrailAPI) UpdateTrailWithContext(arg0 context.Context, arg1 *cloudtrail.UpdateTrailInput, arg2 ...request.Option) (*cloudtrail.UpdateTrailOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateTrailWithContext", varargs...) + ret0, _ := ret[0].(*cloudtrail.UpdateTrailOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateTrailWithContext indicates an expected call of UpdateTrailWithContext +func (mr *MockCloudTrailAPIMockRecorder) UpdateTrailWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrailWithContext", reflect.TypeOf((*MockCloudTrailAPI)(nil).UpdateTrailWithContext), varargs...) +} diff --git a/pkg/mocks/mock_ec2.go b/pkg/mocks/mock_ec2.go new file mode 100644 index 0000000..60f1355 --- /dev/null +++ b/pkg/mocks/mock_ec2.go @@ -0,0 +1,25095 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/ec2/ec2iface (interfaces: EC2API) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + ec2 "github.com/aws/aws-sdk-go/service/ec2" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockEC2API is a mock of EC2API interface +type MockEC2API struct { + ctrl *gomock.Controller + recorder *MockEC2APIMockRecorder +} + +// MockEC2APIMockRecorder is the mock recorder for MockEC2API +type MockEC2APIMockRecorder struct { + mock *MockEC2API +} + +// NewMockEC2API creates a new mock instance +func NewMockEC2API(ctrl *gomock.Controller) *MockEC2API { + mock := &MockEC2API{ctrl: ctrl} + mock.recorder = &MockEC2APIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockEC2API) EXPECT() *MockEC2APIMockRecorder { + return m.recorder +} + +// AcceptReservedInstancesExchangeQuote mocks base method +func (m *MockEC2API) AcceptReservedInstancesExchangeQuote(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuote", arg0) + ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptReservedInstancesExchangeQuote indicates an expected call of AcceptReservedInstancesExchangeQuote +func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuote), arg0) +} + +// AcceptReservedInstancesExchangeQuoteRequest mocks base method +func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteRequest(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.AcceptReservedInstancesExchangeQuoteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) + return ret0, ret1 +} + +// AcceptReservedInstancesExchangeQuoteRequest indicates an expected call of AcceptReservedInstancesExchangeQuoteRequest +func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteRequest), arg0) +} + +// AcceptReservedInstancesExchangeQuoteWithContext mocks base method +func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteWithContext(arg0 context.Context, arg1 *ec2.AcceptReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptReservedInstancesExchangeQuoteWithContext indicates an expected call of AcceptReservedInstancesExchangeQuoteWithContext +func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteWithContext), varargs...) +} + +// AcceptTransitGatewayPeeringAttachment mocks base method +func (m *MockEC2API) AcceptTransitGatewayPeeringAttachment(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachment", arg0) + ret0, _ := ret[0].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptTransitGatewayPeeringAttachment indicates an expected call of AcceptTransitGatewayPeeringAttachment +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachment), arg0) +} + +// AcceptTransitGatewayPeeringAttachmentRequest mocks base method +func (m *MockEC2API) AcceptTransitGatewayPeeringAttachmentRequest(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayPeeringAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput) + return ret0, ret1 +} + +// AcceptTransitGatewayPeeringAttachmentRequest indicates an expected call of AcceptTransitGatewayPeeringAttachmentRequest +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachmentRequest), arg0) +} + +// AcceptTransitGatewayPeeringAttachmentWithContext mocks base method +func (m *MockEC2API) AcceptTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptTransitGatewayPeeringAttachmentWithContext indicates an expected call of AcceptTransitGatewayPeeringAttachmentWithContext +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachmentWithContext), varargs...) +} + +// AcceptTransitGatewayVpcAttachment mocks base method +func (m *MockEC2API) AcceptTransitGatewayVpcAttachment(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachment", arg0) + ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptTransitGatewayVpcAttachment indicates an expected call of AcceptTransitGatewayVpcAttachment +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachment), arg0) +} + +// AcceptTransitGatewayVpcAttachmentRequest mocks base method +func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentRequest(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayVpcAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) + return ret0, ret1 +} + +// AcceptTransitGatewayVpcAttachmentRequest indicates an expected call of AcceptTransitGatewayVpcAttachmentRequest +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentRequest), arg0) +} + +// AcceptTransitGatewayVpcAttachmentWithContext mocks base method +func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptTransitGatewayVpcAttachmentWithContext indicates an expected call of AcceptTransitGatewayVpcAttachmentWithContext +func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentWithContext), varargs...) +} + +// AcceptVpcEndpointConnections mocks base method +func (m *MockEC2API) AcceptVpcEndpointConnections(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*ec2.AcceptVpcEndpointConnectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptVpcEndpointConnections", arg0) + ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptVpcEndpointConnections indicates an expected call of AcceptVpcEndpointConnections +func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnections), arg0) +} + +// AcceptVpcEndpointConnectionsRequest mocks base method +func (m *MockEC2API) AcceptVpcEndpointConnectionsRequest(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*request.Request, *ec2.AcceptVpcEndpointConnectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AcceptVpcEndpointConnectionsOutput) + return ret0, ret1 +} + +// AcceptVpcEndpointConnectionsRequest indicates an expected call of AcceptVpcEndpointConnectionsRequest +func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnectionsRequest), arg0) +} + +// AcceptVpcEndpointConnectionsWithContext mocks base method +func (m *MockEC2API) AcceptVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.AcceptVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.AcceptVpcEndpointConnectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptVpcEndpointConnectionsWithContext indicates an expected call of AcceptVpcEndpointConnectionsWithContext +func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnectionsWithContext), varargs...) +} + +// AcceptVpcPeeringConnection mocks base method +func (m *MockEC2API) AcceptVpcPeeringConnection(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*ec2.AcceptVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptVpcPeeringConnection", arg0) + ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptVpcPeeringConnection indicates an expected call of AcceptVpcPeeringConnection +func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnection), arg0) +} + +// AcceptVpcPeeringConnectionRequest mocks base method +func (m *MockEC2API) AcceptVpcPeeringConnectionRequest(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*request.Request, *ec2.AcceptVpcPeeringConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AcceptVpcPeeringConnectionOutput) + return ret0, ret1 +} + +// AcceptVpcPeeringConnectionRequest indicates an expected call of AcceptVpcPeeringConnectionRequest +func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionRequest), arg0) +} + +// AcceptVpcPeeringConnectionWithContext mocks base method +func (m *MockEC2API) AcceptVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.AcceptVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.AcceptVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AcceptVpcPeeringConnectionWithContext indicates an expected call of AcceptVpcPeeringConnectionWithContext +func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionWithContext), varargs...) +} + +// AdvertiseByoipCidr mocks base method +func (m *MockEC2API) AdvertiseByoipCidr(arg0 *ec2.AdvertiseByoipCidrInput) (*ec2.AdvertiseByoipCidrOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AdvertiseByoipCidr", arg0) + ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AdvertiseByoipCidr indicates an expected call of AdvertiseByoipCidr +func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidr(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidr", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidr), arg0) +} + +// AdvertiseByoipCidrRequest mocks base method +func (m *MockEC2API) AdvertiseByoipCidrRequest(arg0 *ec2.AdvertiseByoipCidrInput) (*request.Request, *ec2.AdvertiseByoipCidrOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AdvertiseByoipCidrRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AdvertiseByoipCidrOutput) + return ret0, ret1 +} + +// AdvertiseByoipCidrRequest indicates an expected call of AdvertiseByoipCidrRequest +func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidrRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrRequest), arg0) +} + +// AdvertiseByoipCidrWithContext mocks base method +func (m *MockEC2API) AdvertiseByoipCidrWithContext(arg0 context.Context, arg1 *ec2.AdvertiseByoipCidrInput, arg2 ...request.Option) (*ec2.AdvertiseByoipCidrOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AdvertiseByoipCidrWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AdvertiseByoipCidrWithContext indicates an expected call of AdvertiseByoipCidrWithContext +func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrWithContext), varargs...) +} + +// AllocateAddress mocks base method +func (m *MockEC2API) AllocateAddress(arg0 *ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AllocateAddress", arg0) + ret0, _ := ret[0].(*ec2.AllocateAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AllocateAddress indicates an expected call of AllocateAddress +func (mr *MockEC2APIMockRecorder) AllocateAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddress", reflect.TypeOf((*MockEC2API)(nil).AllocateAddress), arg0) +} + +// AllocateAddressRequest mocks base method +func (m *MockEC2API) AllocateAddressRequest(arg0 *ec2.AllocateAddressInput) (*request.Request, *ec2.AllocateAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AllocateAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AllocateAddressOutput) + return ret0, ret1 +} + +// AllocateAddressRequest indicates an expected call of AllocateAddressRequest +func (mr *MockEC2APIMockRecorder) AllocateAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressRequest), arg0) +} + +// AllocateAddressWithContext mocks base method +func (m *MockEC2API) AllocateAddressWithContext(arg0 context.Context, arg1 *ec2.AllocateAddressInput, arg2 ...request.Option) (*ec2.AllocateAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AllocateAddressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AllocateAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AllocateAddressWithContext indicates an expected call of AllocateAddressWithContext +func (mr *MockEC2APIMockRecorder) AllocateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressWithContext), varargs...) +} + +// AllocateHosts mocks base method +func (m *MockEC2API) AllocateHosts(arg0 *ec2.AllocateHostsInput) (*ec2.AllocateHostsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AllocateHosts", arg0) + ret0, _ := ret[0].(*ec2.AllocateHostsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AllocateHosts indicates an expected call of AllocateHosts +func (mr *MockEC2APIMockRecorder) AllocateHosts(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHosts", reflect.TypeOf((*MockEC2API)(nil).AllocateHosts), arg0) +} + +// AllocateHostsRequest mocks base method +func (m *MockEC2API) AllocateHostsRequest(arg0 *ec2.AllocateHostsInput) (*request.Request, *ec2.AllocateHostsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AllocateHostsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AllocateHostsOutput) + return ret0, ret1 +} + +// AllocateHostsRequest indicates an expected call of AllocateHostsRequest +func (mr *MockEC2APIMockRecorder) AllocateHostsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsRequest), arg0) +} + +// AllocateHostsWithContext mocks base method +func (m *MockEC2API) AllocateHostsWithContext(arg0 context.Context, arg1 *ec2.AllocateHostsInput, arg2 ...request.Option) (*ec2.AllocateHostsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AllocateHostsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AllocateHostsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AllocateHostsWithContext indicates an expected call of AllocateHostsWithContext +func (mr *MockEC2APIMockRecorder) AllocateHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsWithContext), varargs...) +} + +// ApplySecurityGroupsToClientVpnTargetNetwork mocks base method +func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetwork", arg0) + ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ApplySecurityGroupsToClientVpnTargetNetwork indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetwork +func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetwork), arg0) +} + +// ApplySecurityGroupsToClientVpnTargetNetworkRequest mocks base method +func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*request.Request, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) + return ret0, ret1 +} + +// ApplySecurityGroupsToClientVpnTargetNetworkRequest indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkRequest +func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkRequest), arg0) +} + +// ApplySecurityGroupsToClientVpnTargetNetworkWithContext mocks base method +func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ApplySecurityGroupsToClientVpnTargetNetworkWithContext indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkWithContext +func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkWithContext), varargs...) +} + +// AssignIpv6Addresses mocks base method +func (m *MockEC2API) AssignIpv6Addresses(arg0 *ec2.AssignIpv6AddressesInput) (*ec2.AssignIpv6AddressesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssignIpv6Addresses", arg0) + ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssignIpv6Addresses indicates an expected call of AssignIpv6Addresses +func (mr *MockEC2APIMockRecorder) AssignIpv6Addresses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6Addresses), arg0) +} + +// AssignIpv6AddressesRequest mocks base method +func (m *MockEC2API) AssignIpv6AddressesRequest(arg0 *ec2.AssignIpv6AddressesInput) (*request.Request, *ec2.AssignIpv6AddressesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssignIpv6AddressesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssignIpv6AddressesOutput) + return ret0, ret1 +} + +// AssignIpv6AddressesRequest indicates an expected call of AssignIpv6AddressesRequest +func (mr *MockEC2APIMockRecorder) AssignIpv6AddressesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesRequest), arg0) +} + +// AssignIpv6AddressesWithContext mocks base method +func (m *MockEC2API) AssignIpv6AddressesWithContext(arg0 context.Context, arg1 *ec2.AssignIpv6AddressesInput, arg2 ...request.Option) (*ec2.AssignIpv6AddressesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssignIpv6AddressesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssignIpv6AddressesWithContext indicates an expected call of AssignIpv6AddressesWithContext +func (mr *MockEC2APIMockRecorder) AssignIpv6AddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesWithContext), varargs...) +} + +// AssignPrivateIpAddresses mocks base method +func (m *MockEC2API) AssignPrivateIpAddresses(arg0 *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssignPrivateIpAddresses", arg0) + ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssignPrivateIpAddresses indicates an expected call of AssignPrivateIpAddresses +func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddresses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddresses), arg0) +} + +// AssignPrivateIpAddressesRequest mocks base method +func (m *MockEC2API) AssignPrivateIpAddressesRequest(arg0 *ec2.AssignPrivateIpAddressesInput) (*request.Request, *ec2.AssignPrivateIpAddressesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssignPrivateIpAddressesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssignPrivateIpAddressesOutput) + return ret0, ret1 +} + +// AssignPrivateIpAddressesRequest indicates an expected call of AssignPrivateIpAddressesRequest +func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesRequest), arg0) +} + +// AssignPrivateIpAddressesWithContext mocks base method +func (m *MockEC2API) AssignPrivateIpAddressesWithContext(arg0 context.Context, arg1 *ec2.AssignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.AssignPrivateIpAddressesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssignPrivateIpAddressesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssignPrivateIpAddressesWithContext indicates an expected call of AssignPrivateIpAddressesWithContext +func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesWithContext), varargs...) +} + +// AssociateAddress mocks base method +func (m *MockEC2API) AssociateAddress(arg0 *ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateAddress", arg0) + ret0, _ := ret[0].(*ec2.AssociateAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateAddress indicates an expected call of AssociateAddress +func (mr *MockEC2APIMockRecorder) AssociateAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateAddress), arg0) +} + +// AssociateAddressRequest mocks base method +func (m *MockEC2API) AssociateAddressRequest(arg0 *ec2.AssociateAddressInput) (*request.Request, *ec2.AssociateAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateAddressOutput) + return ret0, ret1 +} + +// AssociateAddressRequest indicates an expected call of AssociateAddressRequest +func (mr *MockEC2APIMockRecorder) AssociateAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateAddressRequest), arg0) +} + +// AssociateAddressWithContext mocks base method +func (m *MockEC2API) AssociateAddressWithContext(arg0 context.Context, arg1 *ec2.AssociateAddressInput, arg2 ...request.Option) (*ec2.AssociateAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateAddressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateAddressWithContext indicates an expected call of AssociateAddressWithContext +func (mr *MockEC2APIMockRecorder) AssociateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateAddressWithContext), varargs...) +} + +// AssociateClientVpnTargetNetwork mocks base method +func (m *MockEC2API) AssociateClientVpnTargetNetwork(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*ec2.AssociateClientVpnTargetNetworkOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetwork", arg0) + ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateClientVpnTargetNetwork indicates an expected call of AssociateClientVpnTargetNetwork +func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetwork), arg0) +} + +// AssociateClientVpnTargetNetworkRequest mocks base method +func (m *MockEC2API) AssociateClientVpnTargetNetworkRequest(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*request.Request, *ec2.AssociateClientVpnTargetNetworkOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateClientVpnTargetNetworkOutput) + return ret0, ret1 +} + +// AssociateClientVpnTargetNetworkRequest indicates an expected call of AssociateClientVpnTargetNetworkRequest +func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetworkRequest), arg0) +} + +// AssociateClientVpnTargetNetworkWithContext mocks base method +func (m *MockEC2API) AssociateClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.AssociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.AssociateClientVpnTargetNetworkOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateClientVpnTargetNetworkWithContext indicates an expected call of AssociateClientVpnTargetNetworkWithContext +func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetworkWithContext), varargs...) +} + +// AssociateDhcpOptions mocks base method +func (m *MockEC2API) AssociateDhcpOptions(arg0 *ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateDhcpOptions", arg0) + ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateDhcpOptions indicates an expected call of AssociateDhcpOptions +func (mr *MockEC2APIMockRecorder) AssociateDhcpOptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptions), arg0) +} + +// AssociateDhcpOptionsRequest mocks base method +func (m *MockEC2API) AssociateDhcpOptionsRequest(arg0 *ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateDhcpOptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateDhcpOptionsOutput) + return ret0, ret1 +} + +// AssociateDhcpOptionsRequest indicates an expected call of AssociateDhcpOptionsRequest +func (mr *MockEC2APIMockRecorder) AssociateDhcpOptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsRequest), arg0) +} + +// AssociateDhcpOptionsWithContext mocks base method +func (m *MockEC2API) AssociateDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.AssociateDhcpOptionsInput, arg2 ...request.Option) (*ec2.AssociateDhcpOptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateDhcpOptionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateDhcpOptionsWithContext indicates an expected call of AssociateDhcpOptionsWithContext +func (mr *MockEC2APIMockRecorder) AssociateDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsWithContext), varargs...) +} + +// AssociateIamInstanceProfile mocks base method +func (m *MockEC2API) AssociateIamInstanceProfile(arg0 *ec2.AssociateIamInstanceProfileInput) (*ec2.AssociateIamInstanceProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateIamInstanceProfile", arg0) + ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateIamInstanceProfile indicates an expected call of AssociateIamInstanceProfile +func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfile), arg0) +} + +// AssociateIamInstanceProfileRequest mocks base method +func (m *MockEC2API) AssociateIamInstanceProfileRequest(arg0 *ec2.AssociateIamInstanceProfileInput) (*request.Request, *ec2.AssociateIamInstanceProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateIamInstanceProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateIamInstanceProfileOutput) + return ret0, ret1 +} + +// AssociateIamInstanceProfileRequest indicates an expected call of AssociateIamInstanceProfileRequest +func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfileRequest), arg0) +} + +// AssociateIamInstanceProfileWithContext mocks base method +func (m *MockEC2API) AssociateIamInstanceProfileWithContext(arg0 context.Context, arg1 *ec2.AssociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.AssociateIamInstanceProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateIamInstanceProfileWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateIamInstanceProfileWithContext indicates an expected call of AssociateIamInstanceProfileWithContext +func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfileWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfileWithContext), varargs...) +} + +// AssociateRouteTable mocks base method +func (m *MockEC2API) AssociateRouteTable(arg0 *ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateRouteTable", arg0) + ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateRouteTable indicates an expected call of AssociateRouteTable +func (mr *MockEC2APIMockRecorder) AssociateRouteTable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTable), arg0) +} + +// AssociateRouteTableRequest mocks base method +func (m *MockEC2API) AssociateRouteTableRequest(arg0 *ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateRouteTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateRouteTableOutput) + return ret0, ret1 +} + +// AssociateRouteTableRequest indicates an expected call of AssociateRouteTableRequest +func (mr *MockEC2APIMockRecorder) AssociateRouteTableRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTableRequest), arg0) +} + +// AssociateRouteTableWithContext mocks base method +func (m *MockEC2API) AssociateRouteTableWithContext(arg0 context.Context, arg1 *ec2.AssociateRouteTableInput, arg2 ...request.Option) (*ec2.AssociateRouteTableOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateRouteTableWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateRouteTableWithContext indicates an expected call of AssociateRouteTableWithContext +func (mr *MockEC2APIMockRecorder) AssociateRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTableWithContext), varargs...) +} + +// AssociateSubnetCidrBlock mocks base method +func (m *MockEC2API) AssociateSubnetCidrBlock(arg0 *ec2.AssociateSubnetCidrBlockInput) (*ec2.AssociateSubnetCidrBlockOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateSubnetCidrBlock", arg0) + ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateSubnetCidrBlock indicates an expected call of AssociateSubnetCidrBlock +func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlock), arg0) +} + +// AssociateSubnetCidrBlockRequest mocks base method +func (m *MockEC2API) AssociateSubnetCidrBlockRequest(arg0 *ec2.AssociateSubnetCidrBlockInput) (*request.Request, *ec2.AssociateSubnetCidrBlockOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateSubnetCidrBlockOutput) + return ret0, ret1 +} + +// AssociateSubnetCidrBlockRequest indicates an expected call of AssociateSubnetCidrBlockRequest +func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlockRequest), arg0) +} + +// AssociateSubnetCidrBlockWithContext mocks base method +func (m *MockEC2API) AssociateSubnetCidrBlockWithContext(arg0 context.Context, arg1 *ec2.AssociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateSubnetCidrBlockOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateSubnetCidrBlockWithContext indicates an expected call of AssociateSubnetCidrBlockWithContext +func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlockWithContext), varargs...) +} + +// AssociateTransitGatewayMulticastDomain mocks base method +func (m *MockEC2API) AssociateTransitGatewayMulticastDomain(arg0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomain", arg0) + ret0, _ := ret[0].(*ec2.AssociateTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateTransitGatewayMulticastDomain indicates an expected call of AssociateTransitGatewayMulticastDomain +func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomain), arg0) +} + +// AssociateTransitGatewayMulticastDomainRequest mocks base method +func (m *MockEC2API) AssociateTransitGatewayMulticastDomainRequest(arg0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.AssociateTransitGatewayMulticastDomainOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomainRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateTransitGatewayMulticastDomainOutput) + return ret0, ret1 +} + +// AssociateTransitGatewayMulticastDomainRequest indicates an expected call of AssociateTransitGatewayMulticastDomainRequest +func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomainRequest), arg0) +} + +// AssociateTransitGatewayMulticastDomainWithContext mocks base method +func (m *MockEC2API) AssociateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomainWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateTransitGatewayMulticastDomainWithContext indicates an expected call of AssociateTransitGatewayMulticastDomainWithContext +func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomainWithContext), varargs...) +} + +// AssociateTransitGatewayRouteTable mocks base method +func (m *MockEC2API) AssociateTransitGatewayRouteTable(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*ec2.AssociateTransitGatewayRouteTableOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTable", arg0) + ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateTransitGatewayRouteTable indicates an expected call of AssociateTransitGatewayRouteTable +func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTable), arg0) +} + +// AssociateTransitGatewayRouteTableRequest mocks base method +func (m *MockEC2API) AssociateTransitGatewayRouteTableRequest(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*request.Request, *ec2.AssociateTransitGatewayRouteTableOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateTransitGatewayRouteTableOutput) + return ret0, ret1 +} + +// AssociateTransitGatewayRouteTableRequest indicates an expected call of AssociateTransitGatewayRouteTableRequest +func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableRequest), arg0) +} + +// AssociateTransitGatewayRouteTableWithContext mocks base method +func (m *MockEC2API) AssociateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayRouteTableOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateTransitGatewayRouteTableWithContext indicates an expected call of AssociateTransitGatewayRouteTableWithContext +func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableWithContext), varargs...) +} + +// AssociateVpcCidrBlock mocks base method +func (m *MockEC2API) AssociateVpcCidrBlock(arg0 *ec2.AssociateVpcCidrBlockInput) (*ec2.AssociateVpcCidrBlockOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateVpcCidrBlock", arg0) + ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateVpcCidrBlock indicates an expected call of AssociateVpcCidrBlock +func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlock), arg0) +} + +// AssociateVpcCidrBlockRequest mocks base method +func (m *MockEC2API) AssociateVpcCidrBlockRequest(arg0 *ec2.AssociateVpcCidrBlockInput) (*request.Request, *ec2.AssociateVpcCidrBlockOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateVpcCidrBlockRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AssociateVpcCidrBlockOutput) + return ret0, ret1 +} + +// AssociateVpcCidrBlockRequest indicates an expected call of AssociateVpcCidrBlockRequest +func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlockRequest), arg0) +} + +// AssociateVpcCidrBlockWithContext mocks base method +func (m *MockEC2API) AssociateVpcCidrBlockWithContext(arg0 context.Context, arg1 *ec2.AssociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateVpcCidrBlockOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssociateVpcCidrBlockWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateVpcCidrBlockWithContext indicates an expected call of AssociateVpcCidrBlockWithContext +func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlockWithContext), varargs...) +} + +// AttachClassicLinkVpc mocks base method +func (m *MockEC2API) AttachClassicLinkVpc(arg0 *ec2.AttachClassicLinkVpcInput) (*ec2.AttachClassicLinkVpcOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachClassicLinkVpc", arg0) + ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachClassicLinkVpc indicates an expected call of AttachClassicLinkVpc +func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpc(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpc), arg0) +} + +// AttachClassicLinkVpcRequest mocks base method +func (m *MockEC2API) AttachClassicLinkVpcRequest(arg0 *ec2.AttachClassicLinkVpcInput) (*request.Request, *ec2.AttachClassicLinkVpcOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachClassicLinkVpcRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AttachClassicLinkVpcOutput) + return ret0, ret1 +} + +// AttachClassicLinkVpcRequest indicates an expected call of AttachClassicLinkVpcRequest +func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpcRequest), arg0) +} + +// AttachClassicLinkVpcWithContext mocks base method +func (m *MockEC2API) AttachClassicLinkVpcWithContext(arg0 context.Context, arg1 *ec2.AttachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.AttachClassicLinkVpcOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachClassicLinkVpcWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachClassicLinkVpcWithContext indicates an expected call of AttachClassicLinkVpcWithContext +func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpcWithContext), varargs...) +} + +// AttachInternetGateway mocks base method +func (m *MockEC2API) AttachInternetGateway(arg0 *ec2.AttachInternetGatewayInput) (*ec2.AttachInternetGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachInternetGateway", arg0) + ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachInternetGateway indicates an expected call of AttachInternetGateway +func (mr *MockEC2APIMockRecorder) AttachInternetGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGateway), arg0) +} + +// AttachInternetGatewayRequest mocks base method +func (m *MockEC2API) AttachInternetGatewayRequest(arg0 *ec2.AttachInternetGatewayInput) (*request.Request, *ec2.AttachInternetGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachInternetGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AttachInternetGatewayOutput) + return ret0, ret1 +} + +// AttachInternetGatewayRequest indicates an expected call of AttachInternetGatewayRequest +func (mr *MockEC2APIMockRecorder) AttachInternetGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGatewayRequest), arg0) +} + +// AttachInternetGatewayWithContext mocks base method +func (m *MockEC2API) AttachInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.AttachInternetGatewayInput, arg2 ...request.Option) (*ec2.AttachInternetGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachInternetGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachInternetGatewayWithContext indicates an expected call of AttachInternetGatewayWithContext +func (mr *MockEC2APIMockRecorder) AttachInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGatewayWithContext), varargs...) +} + +// AttachNetworkInterface mocks base method +func (m *MockEC2API) AttachNetworkInterface(arg0 *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachNetworkInterface", arg0) + ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachNetworkInterface indicates an expected call of AttachNetworkInterface +func (mr *MockEC2APIMockRecorder) AttachNetworkInterface(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterface), arg0) +} + +// AttachNetworkInterfaceRequest mocks base method +func (m *MockEC2API) AttachNetworkInterfaceRequest(arg0 *ec2.AttachNetworkInterfaceInput) (*request.Request, *ec2.AttachNetworkInterfaceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachNetworkInterfaceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AttachNetworkInterfaceOutput) + return ret0, ret1 +} + +// AttachNetworkInterfaceRequest indicates an expected call of AttachNetworkInterfaceRequest +func (mr *MockEC2APIMockRecorder) AttachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterfaceRequest), arg0) +} + +// AttachNetworkInterfaceWithContext mocks base method +func (m *MockEC2API) AttachNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.AttachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.AttachNetworkInterfaceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachNetworkInterfaceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachNetworkInterfaceWithContext indicates an expected call of AttachNetworkInterfaceWithContext +func (mr *MockEC2APIMockRecorder) AttachNetworkInterfaceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterfaceWithContext), varargs...) +} + +// AttachVolume mocks base method +func (m *MockEC2API) AttachVolume(arg0 *ec2.AttachVolumeInput) (*ec2.VolumeAttachment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachVolume", arg0) + ret0, _ := ret[0].(*ec2.VolumeAttachment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachVolume indicates an expected call of AttachVolume +func (mr *MockEC2APIMockRecorder) AttachVolume(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolume", reflect.TypeOf((*MockEC2API)(nil).AttachVolume), arg0) +} + +// AttachVolumeRequest mocks base method +func (m *MockEC2API) AttachVolumeRequest(arg0 *ec2.AttachVolumeInput) (*request.Request, *ec2.VolumeAttachment) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachVolumeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.VolumeAttachment) + return ret0, ret1 +} + +// AttachVolumeRequest indicates an expected call of AttachVolumeRequest +func (mr *MockEC2APIMockRecorder) AttachVolumeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVolumeRequest), arg0) +} + +// AttachVolumeWithContext mocks base method +func (m *MockEC2API) AttachVolumeWithContext(arg0 context.Context, arg1 *ec2.AttachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachVolumeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.VolumeAttachment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachVolumeWithContext indicates an expected call of AttachVolumeWithContext +func (mr *MockEC2APIMockRecorder) AttachVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachVolumeWithContext), varargs...) +} + +// AttachVpnGateway mocks base method +func (m *MockEC2API) AttachVpnGateway(arg0 *ec2.AttachVpnGatewayInput) (*ec2.AttachVpnGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachVpnGateway", arg0) + ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachVpnGateway indicates an expected call of AttachVpnGateway +func (mr *MockEC2APIMockRecorder) AttachVpnGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGateway), arg0) +} + +// AttachVpnGatewayRequest mocks base method +func (m *MockEC2API) AttachVpnGatewayRequest(arg0 *ec2.AttachVpnGatewayInput) (*request.Request, *ec2.AttachVpnGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachVpnGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AttachVpnGatewayOutput) + return ret0, ret1 +} + +// AttachVpnGatewayRequest indicates an expected call of AttachVpnGatewayRequest +func (mr *MockEC2APIMockRecorder) AttachVpnGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGatewayRequest), arg0) +} + +// AttachVpnGatewayWithContext mocks base method +func (m *MockEC2API) AttachVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.AttachVpnGatewayInput, arg2 ...request.Option) (*ec2.AttachVpnGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachVpnGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachVpnGatewayWithContext indicates an expected call of AttachVpnGatewayWithContext +func (mr *MockEC2APIMockRecorder) AttachVpnGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGatewayWithContext), varargs...) +} + +// AuthorizeClientVpnIngress mocks base method +func (m *MockEC2API) AuthorizeClientVpnIngress(arg0 *ec2.AuthorizeClientVpnIngressInput) (*ec2.AuthorizeClientVpnIngressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthorizeClientVpnIngress", arg0) + ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AuthorizeClientVpnIngress indicates an expected call of AuthorizeClientVpnIngress +func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngress), arg0) +} + +// AuthorizeClientVpnIngressRequest mocks base method +func (m *MockEC2API) AuthorizeClientVpnIngressRequest(arg0 *ec2.AuthorizeClientVpnIngressInput) (*request.Request, *ec2.AuthorizeClientVpnIngressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AuthorizeClientVpnIngressOutput) + return ret0, ret1 +} + +// AuthorizeClientVpnIngressRequest indicates an expected call of AuthorizeClientVpnIngressRequest +func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngressRequest), arg0) +} + +// AuthorizeClientVpnIngressWithContext mocks base method +func (m *MockEC2API) AuthorizeClientVpnIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeClientVpnIngressInput, arg2 ...request.Option) (*ec2.AuthorizeClientVpnIngressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AuthorizeClientVpnIngressWithContext indicates an expected call of AuthorizeClientVpnIngressWithContext +func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngressWithContext), varargs...) +} + +// AuthorizeSecurityGroupEgress mocks base method +func (m *MockEC2API) AuthorizeSecurityGroupEgress(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgress", arg0) + ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AuthorizeSecurityGroupEgress indicates an expected call of AuthorizeSecurityGroupEgress +func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgress), arg0) +} + +// AuthorizeSecurityGroupEgressRequest mocks base method +func (m *MockEC2API) AuthorizeSecurityGroupEgressRequest(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*request.Request, *ec2.AuthorizeSecurityGroupEgressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupEgressOutput) + return ret0, ret1 +} + +// AuthorizeSecurityGroupEgressRequest indicates an expected call of AuthorizeSecurityGroupEgressRequest +func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgressRequest), arg0) +} + +// AuthorizeSecurityGroupEgressWithContext mocks base method +func (m *MockEC2API) AuthorizeSecurityGroupEgressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupEgressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AuthorizeSecurityGroupEgressWithContext indicates an expected call of AuthorizeSecurityGroupEgressWithContext +func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgressWithContext), varargs...) +} + +// AuthorizeSecurityGroupIngress mocks base method +func (m *MockEC2API) AuthorizeSecurityGroupIngress(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngress", arg0) + ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AuthorizeSecurityGroupIngress indicates an expected call of AuthorizeSecurityGroupIngress +func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngress), arg0) +} + +// AuthorizeSecurityGroupIngressRequest mocks base method +func (m *MockEC2API) AuthorizeSecurityGroupIngressRequest(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*request.Request, *ec2.AuthorizeSecurityGroupIngressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupIngressOutput) + return ret0, ret1 +} + +// AuthorizeSecurityGroupIngressRequest indicates an expected call of AuthorizeSecurityGroupIngressRequest +func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngressRequest), arg0) +} + +// AuthorizeSecurityGroupIngressWithContext mocks base method +func (m *MockEC2API) AuthorizeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupIngressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AuthorizeSecurityGroupIngressWithContext indicates an expected call of AuthorizeSecurityGroupIngressWithContext +func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngressWithContext), varargs...) +} + +// BundleInstance mocks base method +func (m *MockEC2API) BundleInstance(arg0 *ec2.BundleInstanceInput) (*ec2.BundleInstanceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BundleInstance", arg0) + ret0, _ := ret[0].(*ec2.BundleInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BundleInstance indicates an expected call of BundleInstance +func (mr *MockEC2APIMockRecorder) BundleInstance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstance", reflect.TypeOf((*MockEC2API)(nil).BundleInstance), arg0) +} + +// BundleInstanceRequest mocks base method +func (m *MockEC2API) BundleInstanceRequest(arg0 *ec2.BundleInstanceInput) (*request.Request, *ec2.BundleInstanceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BundleInstanceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.BundleInstanceOutput) + return ret0, ret1 +} + +// BundleInstanceRequest indicates an expected call of BundleInstanceRequest +func (mr *MockEC2APIMockRecorder) BundleInstanceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).BundleInstanceRequest), arg0) +} + +// BundleInstanceWithContext mocks base method +func (m *MockEC2API) BundleInstanceWithContext(arg0 context.Context, arg1 *ec2.BundleInstanceInput, arg2 ...request.Option) (*ec2.BundleInstanceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BundleInstanceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.BundleInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BundleInstanceWithContext indicates an expected call of BundleInstanceWithContext +func (mr *MockEC2APIMockRecorder) BundleInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).BundleInstanceWithContext), varargs...) +} + +// CancelBundleTask mocks base method +func (m *MockEC2API) CancelBundleTask(arg0 *ec2.CancelBundleTaskInput) (*ec2.CancelBundleTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelBundleTask", arg0) + ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelBundleTask indicates an expected call of CancelBundleTask +func (mr *MockEC2APIMockRecorder) CancelBundleTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTask", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTask), arg0) +} + +// CancelBundleTaskRequest mocks base method +func (m *MockEC2API) CancelBundleTaskRequest(arg0 *ec2.CancelBundleTaskInput) (*request.Request, *ec2.CancelBundleTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelBundleTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CancelBundleTaskOutput) + return ret0, ret1 +} + +// CancelBundleTaskRequest indicates an expected call of CancelBundleTaskRequest +func (mr *MockEC2APIMockRecorder) CancelBundleTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTaskRequest), arg0) +} + +// CancelBundleTaskWithContext mocks base method +func (m *MockEC2API) CancelBundleTaskWithContext(arg0 context.Context, arg1 *ec2.CancelBundleTaskInput, arg2 ...request.Option) (*ec2.CancelBundleTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelBundleTaskWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelBundleTaskWithContext indicates an expected call of CancelBundleTaskWithContext +func (mr *MockEC2APIMockRecorder) CancelBundleTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTaskWithContext), varargs...) +} + +// CancelCapacityReservation mocks base method +func (m *MockEC2API) CancelCapacityReservation(arg0 *ec2.CancelCapacityReservationInput) (*ec2.CancelCapacityReservationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelCapacityReservation", arg0) + ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelCapacityReservation indicates an expected call of CancelCapacityReservation +func (mr *MockEC2APIMockRecorder) CancelCapacityReservation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservation), arg0) +} + +// CancelCapacityReservationRequest mocks base method +func (m *MockEC2API) CancelCapacityReservationRequest(arg0 *ec2.CancelCapacityReservationInput) (*request.Request, *ec2.CancelCapacityReservationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelCapacityReservationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CancelCapacityReservationOutput) + return ret0, ret1 +} + +// CancelCapacityReservationRequest indicates an expected call of CancelCapacityReservationRequest +func (mr *MockEC2APIMockRecorder) CancelCapacityReservationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationRequest), arg0) +} + +// CancelCapacityReservationWithContext mocks base method +func (m *MockEC2API) CancelCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.CancelCapacityReservationInput, arg2 ...request.Option) (*ec2.CancelCapacityReservationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelCapacityReservationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelCapacityReservationWithContext indicates an expected call of CancelCapacityReservationWithContext +func (mr *MockEC2APIMockRecorder) CancelCapacityReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationWithContext), varargs...) +} + +// CancelConversionTask mocks base method +func (m *MockEC2API) CancelConversionTask(arg0 *ec2.CancelConversionTaskInput) (*ec2.CancelConversionTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelConversionTask", arg0) + ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelConversionTask indicates an expected call of CancelConversionTask +func (mr *MockEC2APIMockRecorder) CancelConversionTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTask", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTask), arg0) +} + +// CancelConversionTaskRequest mocks base method +func (m *MockEC2API) CancelConversionTaskRequest(arg0 *ec2.CancelConversionTaskInput) (*request.Request, *ec2.CancelConversionTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelConversionTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CancelConversionTaskOutput) + return ret0, ret1 +} + +// CancelConversionTaskRequest indicates an expected call of CancelConversionTaskRequest +func (mr *MockEC2APIMockRecorder) CancelConversionTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTaskRequest), arg0) +} + +// CancelConversionTaskWithContext mocks base method +func (m *MockEC2API) CancelConversionTaskWithContext(arg0 context.Context, arg1 *ec2.CancelConversionTaskInput, arg2 ...request.Option) (*ec2.CancelConversionTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelConversionTaskWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelConversionTaskWithContext indicates an expected call of CancelConversionTaskWithContext +func (mr *MockEC2APIMockRecorder) CancelConversionTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTaskWithContext), varargs...) +} + +// CancelExportTask mocks base method +func (m *MockEC2API) CancelExportTask(arg0 *ec2.CancelExportTaskInput) (*ec2.CancelExportTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelExportTask", arg0) + ret0, _ := ret[0].(*ec2.CancelExportTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelExportTask indicates an expected call of CancelExportTask +func (mr *MockEC2APIMockRecorder) CancelExportTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTask", reflect.TypeOf((*MockEC2API)(nil).CancelExportTask), arg0) +} + +// CancelExportTaskRequest mocks base method +func (m *MockEC2API) CancelExportTaskRequest(arg0 *ec2.CancelExportTaskInput) (*request.Request, *ec2.CancelExportTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelExportTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CancelExportTaskOutput) + return ret0, ret1 +} + +// CancelExportTaskRequest indicates an expected call of CancelExportTaskRequest +func (mr *MockEC2APIMockRecorder) CancelExportTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelExportTaskRequest), arg0) +} + +// CancelExportTaskWithContext mocks base method +func (m *MockEC2API) CancelExportTaskWithContext(arg0 context.Context, arg1 *ec2.CancelExportTaskInput, arg2 ...request.Option) (*ec2.CancelExportTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelExportTaskWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CancelExportTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelExportTaskWithContext indicates an expected call of CancelExportTaskWithContext +func (mr *MockEC2APIMockRecorder) CancelExportTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelExportTaskWithContext), varargs...) +} + +// CancelImportTask mocks base method +func (m *MockEC2API) CancelImportTask(arg0 *ec2.CancelImportTaskInput) (*ec2.CancelImportTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelImportTask", arg0) + ret0, _ := ret[0].(*ec2.CancelImportTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelImportTask indicates an expected call of CancelImportTask +func (mr *MockEC2APIMockRecorder) CancelImportTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTask", reflect.TypeOf((*MockEC2API)(nil).CancelImportTask), arg0) +} + +// CancelImportTaskRequest mocks base method +func (m *MockEC2API) CancelImportTaskRequest(arg0 *ec2.CancelImportTaskInput) (*request.Request, *ec2.CancelImportTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelImportTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CancelImportTaskOutput) + return ret0, ret1 +} + +// CancelImportTaskRequest indicates an expected call of CancelImportTaskRequest +func (mr *MockEC2APIMockRecorder) CancelImportTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelImportTaskRequest), arg0) +} + +// CancelImportTaskWithContext mocks base method +func (m *MockEC2API) CancelImportTaskWithContext(arg0 context.Context, arg1 *ec2.CancelImportTaskInput, arg2 ...request.Option) (*ec2.CancelImportTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelImportTaskWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CancelImportTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelImportTaskWithContext indicates an expected call of CancelImportTaskWithContext +func (mr *MockEC2APIMockRecorder) CancelImportTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelImportTaskWithContext), varargs...) +} + +// CancelReservedInstancesListing mocks base method +func (m *MockEC2API) CancelReservedInstancesListing(arg0 *ec2.CancelReservedInstancesListingInput) (*ec2.CancelReservedInstancesListingOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelReservedInstancesListing", arg0) + ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelReservedInstancesListing indicates an expected call of CancelReservedInstancesListing +func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListing(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListing), arg0) +} + +// CancelReservedInstancesListingRequest mocks base method +func (m *MockEC2API) CancelReservedInstancesListingRequest(arg0 *ec2.CancelReservedInstancesListingInput) (*request.Request, *ec2.CancelReservedInstancesListingOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelReservedInstancesListingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CancelReservedInstancesListingOutput) + return ret0, ret1 +} + +// CancelReservedInstancesListingRequest indicates an expected call of CancelReservedInstancesListingRequest +func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListingRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListingRequest), arg0) +} + +// CancelReservedInstancesListingWithContext mocks base method +func (m *MockEC2API) CancelReservedInstancesListingWithContext(arg0 context.Context, arg1 *ec2.CancelReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CancelReservedInstancesListingOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelReservedInstancesListingWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelReservedInstancesListingWithContext indicates an expected call of CancelReservedInstancesListingWithContext +func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListingWithContext), varargs...) +} + +// CancelSpotFleetRequests mocks base method +func (m *MockEC2API) CancelSpotFleetRequests(arg0 *ec2.CancelSpotFleetRequestsInput) (*ec2.CancelSpotFleetRequestsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelSpotFleetRequests", arg0) + ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelSpotFleetRequests indicates an expected call of CancelSpotFleetRequests +func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequests(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequests), arg0) +} + +// CancelSpotFleetRequestsRequest mocks base method +func (m *MockEC2API) CancelSpotFleetRequestsRequest(arg0 *ec2.CancelSpotFleetRequestsInput) (*request.Request, *ec2.CancelSpotFleetRequestsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelSpotFleetRequestsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CancelSpotFleetRequestsOutput) + return ret0, ret1 +} + +// CancelSpotFleetRequestsRequest indicates an expected call of CancelSpotFleetRequestsRequest +func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequestsRequest), arg0) +} + +// CancelSpotFleetRequestsWithContext mocks base method +func (m *MockEC2API) CancelSpotFleetRequestsWithContext(arg0 context.Context, arg1 *ec2.CancelSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotFleetRequestsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelSpotFleetRequestsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelSpotFleetRequestsWithContext indicates an expected call of CancelSpotFleetRequestsWithContext +func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequestsWithContext), varargs...) +} + +// CancelSpotInstanceRequests mocks base method +func (m *MockEC2API) CancelSpotInstanceRequests(arg0 *ec2.CancelSpotInstanceRequestsInput) (*ec2.CancelSpotInstanceRequestsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelSpotInstanceRequests", arg0) + ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelSpotInstanceRequests indicates an expected call of CancelSpotInstanceRequests +func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequests(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequests), arg0) +} + +// CancelSpotInstanceRequestsRequest mocks base method +func (m *MockEC2API) CancelSpotInstanceRequestsRequest(arg0 *ec2.CancelSpotInstanceRequestsInput) (*request.Request, *ec2.CancelSpotInstanceRequestsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CancelSpotInstanceRequestsOutput) + return ret0, ret1 +} + +// CancelSpotInstanceRequestsRequest indicates an expected call of CancelSpotInstanceRequestsRequest +func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequestsRequest), arg0) +} + +// CancelSpotInstanceRequestsWithContext mocks base method +func (m *MockEC2API) CancelSpotInstanceRequestsWithContext(arg0 context.Context, arg1 *ec2.CancelSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotInstanceRequestsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelSpotInstanceRequestsWithContext indicates an expected call of CancelSpotInstanceRequestsWithContext +func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequestsWithContext), varargs...) +} + +// ConfirmProductInstance mocks base method +func (m *MockEC2API) ConfirmProductInstance(arg0 *ec2.ConfirmProductInstanceInput) (*ec2.ConfirmProductInstanceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfirmProductInstance", arg0) + ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConfirmProductInstance indicates an expected call of ConfirmProductInstance +func (mr *MockEC2APIMockRecorder) ConfirmProductInstance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstance", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstance), arg0) +} + +// ConfirmProductInstanceRequest mocks base method +func (m *MockEC2API) ConfirmProductInstanceRequest(arg0 *ec2.ConfirmProductInstanceInput) (*request.Request, *ec2.ConfirmProductInstanceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfirmProductInstanceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ConfirmProductInstanceOutput) + return ret0, ret1 +} + +// ConfirmProductInstanceRequest indicates an expected call of ConfirmProductInstanceRequest +func (mr *MockEC2APIMockRecorder) ConfirmProductInstanceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstanceRequest), arg0) +} + +// ConfirmProductInstanceWithContext mocks base method +func (m *MockEC2API) ConfirmProductInstanceWithContext(arg0 context.Context, arg1 *ec2.ConfirmProductInstanceInput, arg2 ...request.Option) (*ec2.ConfirmProductInstanceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ConfirmProductInstanceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConfirmProductInstanceWithContext indicates an expected call of ConfirmProductInstanceWithContext +func (mr *MockEC2APIMockRecorder) ConfirmProductInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstanceWithContext), varargs...) +} + +// CopyFpgaImage mocks base method +func (m *MockEC2API) CopyFpgaImage(arg0 *ec2.CopyFpgaImageInput) (*ec2.CopyFpgaImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CopyFpgaImage", arg0) + ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CopyFpgaImage indicates an expected call of CopyFpgaImage +func (mr *MockEC2APIMockRecorder) CopyFpgaImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImage), arg0) +} + +// CopyFpgaImageRequest mocks base method +func (m *MockEC2API) CopyFpgaImageRequest(arg0 *ec2.CopyFpgaImageInput) (*request.Request, *ec2.CopyFpgaImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CopyFpgaImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CopyFpgaImageOutput) + return ret0, ret1 +} + +// CopyFpgaImageRequest indicates an expected call of CopyFpgaImageRequest +func (mr *MockEC2APIMockRecorder) CopyFpgaImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImageRequest), arg0) +} + +// CopyFpgaImageWithContext mocks base method +func (m *MockEC2API) CopyFpgaImageWithContext(arg0 context.Context, arg1 *ec2.CopyFpgaImageInput, arg2 ...request.Option) (*ec2.CopyFpgaImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CopyFpgaImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CopyFpgaImageWithContext indicates an expected call of CopyFpgaImageWithContext +func (mr *MockEC2APIMockRecorder) CopyFpgaImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImageWithContext), varargs...) +} + +// CopyImage mocks base method +func (m *MockEC2API) CopyImage(arg0 *ec2.CopyImageInput) (*ec2.CopyImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CopyImage", arg0) + ret0, _ := ret[0].(*ec2.CopyImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CopyImage indicates an expected call of CopyImage +func (mr *MockEC2APIMockRecorder) CopyImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImage", reflect.TypeOf((*MockEC2API)(nil).CopyImage), arg0) +} + +// CopyImageRequest mocks base method +func (m *MockEC2API) CopyImageRequest(arg0 *ec2.CopyImageInput) (*request.Request, *ec2.CopyImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CopyImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CopyImageOutput) + return ret0, ret1 +} + +// CopyImageRequest indicates an expected call of CopyImageRequest +func (mr *MockEC2APIMockRecorder) CopyImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyImageRequest), arg0) +} + +// CopyImageWithContext mocks base method +func (m *MockEC2API) CopyImageWithContext(arg0 context.Context, arg1 *ec2.CopyImageInput, arg2 ...request.Option) (*ec2.CopyImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CopyImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CopyImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CopyImageWithContext indicates an expected call of CopyImageWithContext +func (mr *MockEC2APIMockRecorder) CopyImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CopyImageWithContext), varargs...) +} + +// CopySnapshot mocks base method +func (m *MockEC2API) CopySnapshot(arg0 *ec2.CopySnapshotInput) (*ec2.CopySnapshotOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CopySnapshot", arg0) + ret0, _ := ret[0].(*ec2.CopySnapshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CopySnapshot indicates an expected call of CopySnapshot +func (mr *MockEC2APIMockRecorder) CopySnapshot(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshot", reflect.TypeOf((*MockEC2API)(nil).CopySnapshot), arg0) +} + +// CopySnapshotRequest mocks base method +func (m *MockEC2API) CopySnapshotRequest(arg0 *ec2.CopySnapshotInput) (*request.Request, *ec2.CopySnapshotOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CopySnapshotRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CopySnapshotOutput) + return ret0, ret1 +} + +// CopySnapshotRequest indicates an expected call of CopySnapshotRequest +func (mr *MockEC2APIMockRecorder) CopySnapshotRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CopySnapshotRequest), arg0) +} + +// CopySnapshotWithContext mocks base method +func (m *MockEC2API) CopySnapshotWithContext(arg0 context.Context, arg1 *ec2.CopySnapshotInput, arg2 ...request.Option) (*ec2.CopySnapshotOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CopySnapshotWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CopySnapshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CopySnapshotWithContext indicates an expected call of CopySnapshotWithContext +func (mr *MockEC2APIMockRecorder) CopySnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).CopySnapshotWithContext), varargs...) +} + +// CreateCapacityReservation mocks base method +func (m *MockEC2API) CreateCapacityReservation(arg0 *ec2.CreateCapacityReservationInput) (*ec2.CreateCapacityReservationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCapacityReservation", arg0) + ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCapacityReservation indicates an expected call of CreateCapacityReservation +func (mr *MockEC2APIMockRecorder) CreateCapacityReservation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservation), arg0) +} + +// CreateCapacityReservationRequest mocks base method +func (m *MockEC2API) CreateCapacityReservationRequest(arg0 *ec2.CreateCapacityReservationInput) (*request.Request, *ec2.CreateCapacityReservationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCapacityReservationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateCapacityReservationOutput) + return ret0, ret1 +} + +// CreateCapacityReservationRequest indicates an expected call of CreateCapacityReservationRequest +func (mr *MockEC2APIMockRecorder) CreateCapacityReservationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationRequest), arg0) +} + +// CreateCapacityReservationWithContext mocks base method +func (m *MockEC2API) CreateCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.CreateCapacityReservationInput, arg2 ...request.Option) (*ec2.CreateCapacityReservationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateCapacityReservationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCapacityReservationWithContext indicates an expected call of CreateCapacityReservationWithContext +func (mr *MockEC2APIMockRecorder) CreateCapacityReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationWithContext), varargs...) +} + +// CreateCarrierGateway mocks base method +func (m *MockEC2API) CreateCarrierGateway(arg0 *ec2.CreateCarrierGatewayInput) (*ec2.CreateCarrierGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCarrierGateway", arg0) + ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCarrierGateway indicates an expected call of CreateCarrierGateway +func (mr *MockEC2APIMockRecorder) CreateCarrierGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGateway), arg0) +} + +// CreateCarrierGatewayRequest mocks base method +func (m *MockEC2API) CreateCarrierGatewayRequest(arg0 *ec2.CreateCarrierGatewayInput) (*request.Request, *ec2.CreateCarrierGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCarrierGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateCarrierGatewayOutput) + return ret0, ret1 +} + +// CreateCarrierGatewayRequest indicates an expected call of CreateCarrierGatewayRequest +func (mr *MockEC2APIMockRecorder) CreateCarrierGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGatewayRequest), arg0) +} + +// CreateCarrierGatewayWithContext mocks base method +func (m *MockEC2API) CreateCarrierGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateCarrierGatewayInput, arg2 ...request.Option) (*ec2.CreateCarrierGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateCarrierGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCarrierGatewayWithContext indicates an expected call of CreateCarrierGatewayWithContext +func (mr *MockEC2APIMockRecorder) CreateCarrierGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCarrierGatewayWithContext), varargs...) +} + +// CreateClientVpnEndpoint mocks base method +func (m *MockEC2API) CreateClientVpnEndpoint(arg0 *ec2.CreateClientVpnEndpointInput) (*ec2.CreateClientVpnEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClientVpnEndpoint", arg0) + ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateClientVpnEndpoint indicates an expected call of CreateClientVpnEndpoint +func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpoint), arg0) +} + +// CreateClientVpnEndpointRequest mocks base method +func (m *MockEC2API) CreateClientVpnEndpointRequest(arg0 *ec2.CreateClientVpnEndpointInput) (*request.Request, *ec2.CreateClientVpnEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClientVpnEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateClientVpnEndpointOutput) + return ret0, ret1 +} + +// CreateClientVpnEndpointRequest indicates an expected call of CreateClientVpnEndpointRequest +func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpointRequest), arg0) +} + +// CreateClientVpnEndpointWithContext mocks base method +func (m *MockEC2API) CreateClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateClientVpnEndpointInput, arg2 ...request.Option) (*ec2.CreateClientVpnEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateClientVpnEndpointWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateClientVpnEndpointWithContext indicates an expected call of CreateClientVpnEndpointWithContext +func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpointWithContext), varargs...) +} + +// CreateClientVpnRoute mocks base method +func (m *MockEC2API) CreateClientVpnRoute(arg0 *ec2.CreateClientVpnRouteInput) (*ec2.CreateClientVpnRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClientVpnRoute", arg0) + ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateClientVpnRoute indicates an expected call of CreateClientVpnRoute +func (mr *MockEC2APIMockRecorder) CreateClientVpnRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRoute), arg0) +} + +// CreateClientVpnRouteRequest mocks base method +func (m *MockEC2API) CreateClientVpnRouteRequest(arg0 *ec2.CreateClientVpnRouteInput) (*request.Request, *ec2.CreateClientVpnRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateClientVpnRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateClientVpnRouteOutput) + return ret0, ret1 +} + +// CreateClientVpnRouteRequest indicates an expected call of CreateClientVpnRouteRequest +func (mr *MockEC2APIMockRecorder) CreateClientVpnRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRouteRequest), arg0) +} + +// CreateClientVpnRouteWithContext mocks base method +func (m *MockEC2API) CreateClientVpnRouteWithContext(arg0 context.Context, arg1 *ec2.CreateClientVpnRouteInput, arg2 ...request.Option) (*ec2.CreateClientVpnRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateClientVpnRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateClientVpnRouteWithContext indicates an expected call of CreateClientVpnRouteWithContext +func (mr *MockEC2APIMockRecorder) CreateClientVpnRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRouteWithContext), varargs...) +} + +// CreateCustomerGateway mocks base method +func (m *MockEC2API) CreateCustomerGateway(arg0 *ec2.CreateCustomerGatewayInput) (*ec2.CreateCustomerGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCustomerGateway", arg0) + ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCustomerGateway indicates an expected call of CreateCustomerGateway +func (mr *MockEC2APIMockRecorder) CreateCustomerGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGateway), arg0) +} + +// CreateCustomerGatewayRequest mocks base method +func (m *MockEC2API) CreateCustomerGatewayRequest(arg0 *ec2.CreateCustomerGatewayInput) (*request.Request, *ec2.CreateCustomerGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCustomerGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateCustomerGatewayOutput) + return ret0, ret1 +} + +// CreateCustomerGatewayRequest indicates an expected call of CreateCustomerGatewayRequest +func (mr *MockEC2APIMockRecorder) CreateCustomerGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGatewayRequest), arg0) +} + +// CreateCustomerGatewayWithContext mocks base method +func (m *MockEC2API) CreateCustomerGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateCustomerGatewayInput, arg2 ...request.Option) (*ec2.CreateCustomerGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateCustomerGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCustomerGatewayWithContext indicates an expected call of CreateCustomerGatewayWithContext +func (mr *MockEC2APIMockRecorder) CreateCustomerGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGatewayWithContext), varargs...) +} + +// CreateDefaultSubnet mocks base method +func (m *MockEC2API) CreateDefaultSubnet(arg0 *ec2.CreateDefaultSubnetInput) (*ec2.CreateDefaultSubnetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateDefaultSubnet", arg0) + ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateDefaultSubnet indicates an expected call of CreateDefaultSubnet +func (mr *MockEC2APIMockRecorder) CreateDefaultSubnet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnet), arg0) +} + +// CreateDefaultSubnetRequest mocks base method +func (m *MockEC2API) CreateDefaultSubnetRequest(arg0 *ec2.CreateDefaultSubnetInput) (*request.Request, *ec2.CreateDefaultSubnetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateDefaultSubnetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateDefaultSubnetOutput) + return ret0, ret1 +} + +// CreateDefaultSubnetRequest indicates an expected call of CreateDefaultSubnetRequest +func (mr *MockEC2APIMockRecorder) CreateDefaultSubnetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnetRequest), arg0) +} + +// CreateDefaultSubnetWithContext mocks base method +func (m *MockEC2API) CreateDefaultSubnetWithContext(arg0 context.Context, arg1 *ec2.CreateDefaultSubnetInput, arg2 ...request.Option) (*ec2.CreateDefaultSubnetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateDefaultSubnetWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateDefaultSubnetWithContext indicates an expected call of CreateDefaultSubnetWithContext +func (mr *MockEC2APIMockRecorder) CreateDefaultSubnetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnetWithContext), varargs...) +} + +// CreateDefaultVpc mocks base method +func (m *MockEC2API) CreateDefaultVpc(arg0 *ec2.CreateDefaultVpcInput) (*ec2.CreateDefaultVpcOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateDefaultVpc", arg0) + ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateDefaultVpc indicates an expected call of CreateDefaultVpc +func (mr *MockEC2APIMockRecorder) CreateDefaultVpc(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpc", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpc), arg0) +} + +// CreateDefaultVpcRequest mocks base method +func (m *MockEC2API) CreateDefaultVpcRequest(arg0 *ec2.CreateDefaultVpcInput) (*request.Request, *ec2.CreateDefaultVpcOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateDefaultVpcRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateDefaultVpcOutput) + return ret0, ret1 +} + +// CreateDefaultVpcRequest indicates an expected call of CreateDefaultVpcRequest +func (mr *MockEC2APIMockRecorder) CreateDefaultVpcRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpcRequest), arg0) +} + +// CreateDefaultVpcWithContext mocks base method +func (m *MockEC2API) CreateDefaultVpcWithContext(arg0 context.Context, arg1 *ec2.CreateDefaultVpcInput, arg2 ...request.Option) (*ec2.CreateDefaultVpcOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateDefaultVpcWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateDefaultVpcWithContext indicates an expected call of CreateDefaultVpcWithContext +func (mr *MockEC2APIMockRecorder) CreateDefaultVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpcWithContext), varargs...) +} + +// CreateDhcpOptions mocks base method +func (m *MockEC2API) CreateDhcpOptions(arg0 *ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateDhcpOptions", arg0) + ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateDhcpOptions indicates an expected call of CreateDhcpOptions +func (mr *MockEC2APIMockRecorder) CreateDhcpOptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptions), arg0) +} + +// CreateDhcpOptionsRequest mocks base method +func (m *MockEC2API) CreateDhcpOptionsRequest(arg0 *ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateDhcpOptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateDhcpOptionsOutput) + return ret0, ret1 +} + +// CreateDhcpOptionsRequest indicates an expected call of CreateDhcpOptionsRequest +func (mr *MockEC2APIMockRecorder) CreateDhcpOptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptionsRequest), arg0) +} + +// CreateDhcpOptionsWithContext mocks base method +func (m *MockEC2API) CreateDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.CreateDhcpOptionsInput, arg2 ...request.Option) (*ec2.CreateDhcpOptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateDhcpOptionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateDhcpOptionsWithContext indicates an expected call of CreateDhcpOptionsWithContext +func (mr *MockEC2APIMockRecorder) CreateDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptionsWithContext), varargs...) +} + +// CreateEgressOnlyInternetGateway mocks base method +func (m *MockEC2API) CreateEgressOnlyInternetGateway(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGateway", arg0) + ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateEgressOnlyInternetGateway indicates an expected call of CreateEgressOnlyInternetGateway +func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGateway), arg0) +} + +// CreateEgressOnlyInternetGatewayRequest mocks base method +func (m *MockEC2API) CreateEgressOnlyInternetGatewayRequest(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*request.Request, *ec2.CreateEgressOnlyInternetGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateEgressOnlyInternetGatewayOutput) + return ret0, ret1 +} + +// CreateEgressOnlyInternetGatewayRequest indicates an expected call of CreateEgressOnlyInternetGatewayRequest +func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayRequest), arg0) +} + +// CreateEgressOnlyInternetGatewayWithContext mocks base method +func (m *MockEC2API) CreateEgressOnlyInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateEgressOnlyInternetGatewayWithContext indicates an expected call of CreateEgressOnlyInternetGatewayWithContext +func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayWithContext), varargs...) +} + +// CreateFleet mocks base method +func (m *MockEC2API) CreateFleet(arg0 *ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFleet", arg0) + ret0, _ := ret[0].(*ec2.CreateFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFleet indicates an expected call of CreateFleet +func (mr *MockEC2APIMockRecorder) CreateFleet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleet", reflect.TypeOf((*MockEC2API)(nil).CreateFleet), arg0) +} + +// CreateFleetRequest mocks base method +func (m *MockEC2API) CreateFleetRequest(arg0 *ec2.CreateFleetInput) (*request.Request, *ec2.CreateFleetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFleetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateFleetOutput) + return ret0, ret1 +} + +// CreateFleetRequest indicates an expected call of CreateFleetRequest +func (mr *MockEC2APIMockRecorder) CreateFleetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFleetRequest), arg0) +} + +// CreateFleetWithContext mocks base method +func (m *MockEC2API) CreateFleetWithContext(arg0 context.Context, arg1 *ec2.CreateFleetInput, arg2 ...request.Option) (*ec2.CreateFleetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateFleetWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFleetWithContext indicates an expected call of CreateFleetWithContext +func (mr *MockEC2APIMockRecorder) CreateFleetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFleetWithContext), varargs...) +} + +// CreateFlowLogs mocks base method +func (m *MockEC2API) CreateFlowLogs(arg0 *ec2.CreateFlowLogsInput) (*ec2.CreateFlowLogsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFlowLogs", arg0) + ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFlowLogs indicates an expected call of CreateFlowLogs +func (mr *MockEC2APIMockRecorder) CreateFlowLogs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogs", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogs), arg0) +} + +// CreateFlowLogsRequest mocks base method +func (m *MockEC2API) CreateFlowLogsRequest(arg0 *ec2.CreateFlowLogsInput) (*request.Request, *ec2.CreateFlowLogsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFlowLogsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateFlowLogsOutput) + return ret0, ret1 +} + +// CreateFlowLogsRequest indicates an expected call of CreateFlowLogsRequest +func (mr *MockEC2APIMockRecorder) CreateFlowLogsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogsRequest), arg0) +} + +// CreateFlowLogsWithContext mocks base method +func (m *MockEC2API) CreateFlowLogsWithContext(arg0 context.Context, arg1 *ec2.CreateFlowLogsInput, arg2 ...request.Option) (*ec2.CreateFlowLogsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateFlowLogsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFlowLogsWithContext indicates an expected call of CreateFlowLogsWithContext +func (mr *MockEC2APIMockRecorder) CreateFlowLogsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogsWithContext), varargs...) +} + +// CreateFpgaImage mocks base method +func (m *MockEC2API) CreateFpgaImage(arg0 *ec2.CreateFpgaImageInput) (*ec2.CreateFpgaImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFpgaImage", arg0) + ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFpgaImage indicates an expected call of CreateFpgaImage +func (mr *MockEC2APIMockRecorder) CreateFpgaImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImage), arg0) +} + +// CreateFpgaImageRequest mocks base method +func (m *MockEC2API) CreateFpgaImageRequest(arg0 *ec2.CreateFpgaImageInput) (*request.Request, *ec2.CreateFpgaImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateFpgaImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateFpgaImageOutput) + return ret0, ret1 +} + +// CreateFpgaImageRequest indicates an expected call of CreateFpgaImageRequest +func (mr *MockEC2APIMockRecorder) CreateFpgaImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImageRequest), arg0) +} + +// CreateFpgaImageWithContext mocks base method +func (m *MockEC2API) CreateFpgaImageWithContext(arg0 context.Context, arg1 *ec2.CreateFpgaImageInput, arg2 ...request.Option) (*ec2.CreateFpgaImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateFpgaImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateFpgaImageWithContext indicates an expected call of CreateFpgaImageWithContext +func (mr *MockEC2APIMockRecorder) CreateFpgaImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImageWithContext), varargs...) +} + +// CreateImage mocks base method +func (m *MockEC2API) CreateImage(arg0 *ec2.CreateImageInput) (*ec2.CreateImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateImage", arg0) + ret0, _ := ret[0].(*ec2.CreateImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateImage indicates an expected call of CreateImage +func (mr *MockEC2APIMockRecorder) CreateImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockEC2API)(nil).CreateImage), arg0) +} + +// CreateImageRequest mocks base method +func (m *MockEC2API) CreateImageRequest(arg0 *ec2.CreateImageInput) (*request.Request, *ec2.CreateImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateImageOutput) + return ret0, ret1 +} + +// CreateImageRequest indicates an expected call of CreateImageRequest +func (mr *MockEC2APIMockRecorder) CreateImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateImageRequest), arg0) +} + +// CreateImageWithContext mocks base method +func (m *MockEC2API) CreateImageWithContext(arg0 context.Context, arg1 *ec2.CreateImageInput, arg2 ...request.Option) (*ec2.CreateImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateImageWithContext indicates an expected call of CreateImageWithContext +func (mr *MockEC2APIMockRecorder) CreateImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateImageWithContext), varargs...) +} + +// CreateInstanceExportTask mocks base method +func (m *MockEC2API) CreateInstanceExportTask(arg0 *ec2.CreateInstanceExportTaskInput) (*ec2.CreateInstanceExportTaskOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInstanceExportTask", arg0) + ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateInstanceExportTask indicates an expected call of CreateInstanceExportTask +func (mr *MockEC2APIMockRecorder) CreateInstanceExportTask(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTask", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTask), arg0) +} + +// CreateInstanceExportTaskRequest mocks base method +func (m *MockEC2API) CreateInstanceExportTaskRequest(arg0 *ec2.CreateInstanceExportTaskInput) (*request.Request, *ec2.CreateInstanceExportTaskOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInstanceExportTaskRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateInstanceExportTaskOutput) + return ret0, ret1 +} + +// CreateInstanceExportTaskRequest indicates an expected call of CreateInstanceExportTaskRequest +func (mr *MockEC2APIMockRecorder) CreateInstanceExportTaskRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTaskRequest), arg0) +} + +// CreateInstanceExportTaskWithContext mocks base method +func (m *MockEC2API) CreateInstanceExportTaskWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceExportTaskInput, arg2 ...request.Option) (*ec2.CreateInstanceExportTaskOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateInstanceExportTaskWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateInstanceExportTaskWithContext indicates an expected call of CreateInstanceExportTaskWithContext +func (mr *MockEC2APIMockRecorder) CreateInstanceExportTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTaskWithContext), varargs...) +} + +// CreateInternetGateway mocks base method +func (m *MockEC2API) CreateInternetGateway(arg0 *ec2.CreateInternetGatewayInput) (*ec2.CreateInternetGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInternetGateway", arg0) + ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateInternetGateway indicates an expected call of CreateInternetGateway +func (mr *MockEC2APIMockRecorder) CreateInternetGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGateway), arg0) +} + +// CreateInternetGatewayRequest mocks base method +func (m *MockEC2API) CreateInternetGatewayRequest(arg0 *ec2.CreateInternetGatewayInput) (*request.Request, *ec2.CreateInternetGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInternetGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateInternetGatewayOutput) + return ret0, ret1 +} + +// CreateInternetGatewayRequest indicates an expected call of CreateInternetGatewayRequest +func (mr *MockEC2APIMockRecorder) CreateInternetGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGatewayRequest), arg0) +} + +// CreateInternetGatewayWithContext mocks base method +func (m *MockEC2API) CreateInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateInternetGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateInternetGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateInternetGatewayWithContext indicates an expected call of CreateInternetGatewayWithContext +func (mr *MockEC2APIMockRecorder) CreateInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGatewayWithContext), varargs...) +} + +// CreateKeyPair mocks base method +func (m *MockEC2API) CreateKeyPair(arg0 *ec2.CreateKeyPairInput) (*ec2.CreateKeyPairOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateKeyPair", arg0) + ret0, _ := ret[0].(*ec2.CreateKeyPairOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateKeyPair indicates an expected call of CreateKeyPair +func (mr *MockEC2APIMockRecorder) CreateKeyPair(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPair", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPair), arg0) +} + +// CreateKeyPairRequest mocks base method +func (m *MockEC2API) CreateKeyPairRequest(arg0 *ec2.CreateKeyPairInput) (*request.Request, *ec2.CreateKeyPairOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateKeyPairRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateKeyPairOutput) + return ret0, ret1 +} + +// CreateKeyPairRequest indicates an expected call of CreateKeyPairRequest +func (mr *MockEC2APIMockRecorder) CreateKeyPairRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPairRequest), arg0) +} + +// CreateKeyPairWithContext mocks base method +func (m *MockEC2API) CreateKeyPairWithContext(arg0 context.Context, arg1 *ec2.CreateKeyPairInput, arg2 ...request.Option) (*ec2.CreateKeyPairOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateKeyPairWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateKeyPairOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateKeyPairWithContext indicates an expected call of CreateKeyPairWithContext +func (mr *MockEC2APIMockRecorder) CreateKeyPairWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPairWithContext), varargs...) +} + +// CreateLaunchTemplate mocks base method +func (m *MockEC2API) CreateLaunchTemplate(arg0 *ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLaunchTemplate", arg0) + ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLaunchTemplate indicates an expected call of CreateLaunchTemplate +func (mr *MockEC2APIMockRecorder) CreateLaunchTemplate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplate), arg0) +} + +// CreateLaunchTemplateRequest mocks base method +func (m *MockEC2API) CreateLaunchTemplateRequest(arg0 *ec2.CreateLaunchTemplateInput) (*request.Request, *ec2.CreateLaunchTemplateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLaunchTemplateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateLaunchTemplateOutput) + return ret0, ret1 +} + +// CreateLaunchTemplateRequest indicates an expected call of CreateLaunchTemplateRequest +func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateRequest), arg0) +} + +// CreateLaunchTemplateVersion mocks base method +func (m *MockEC2API) CreateLaunchTemplateVersion(arg0 *ec2.CreateLaunchTemplateVersionInput) (*ec2.CreateLaunchTemplateVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLaunchTemplateVersion", arg0) + ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLaunchTemplateVersion indicates an expected call of CreateLaunchTemplateVersion +func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersion", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersion), arg0) +} + +// CreateLaunchTemplateVersionRequest mocks base method +func (m *MockEC2API) CreateLaunchTemplateVersionRequest(arg0 *ec2.CreateLaunchTemplateVersionInput) (*request.Request, *ec2.CreateLaunchTemplateVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateLaunchTemplateVersionOutput) + return ret0, ret1 +} + +// CreateLaunchTemplateVersionRequest indicates an expected call of CreateLaunchTemplateVersionRequest +func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersionRequest), arg0) +} + +// CreateLaunchTemplateVersionWithContext mocks base method +func (m *MockEC2API) CreateLaunchTemplateVersionWithContext(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateVersionInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLaunchTemplateVersionWithContext indicates an expected call of CreateLaunchTemplateVersionWithContext +func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersionWithContext), varargs...) +} + +// CreateLaunchTemplateWithContext mocks base method +func (m *MockEC2API) CreateLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateLaunchTemplateWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLaunchTemplateWithContext indicates an expected call of CreateLaunchTemplateWithContext +func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateWithContext), varargs...) +} + +// CreateLocalGatewayRoute mocks base method +func (m *MockEC2API) CreateLocalGatewayRoute(arg0 *ec2.CreateLocalGatewayRouteInput) (*ec2.CreateLocalGatewayRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLocalGatewayRoute", arg0) + ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLocalGatewayRoute indicates an expected call of CreateLocalGatewayRoute +func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRoute), arg0) +} + +// CreateLocalGatewayRouteRequest mocks base method +func (m *MockEC2API) CreateLocalGatewayRouteRequest(arg0 *ec2.CreateLocalGatewayRouteInput) (*request.Request, *ec2.CreateLocalGatewayRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLocalGatewayRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteOutput) + return ret0, ret1 +} + +// CreateLocalGatewayRouteRequest indicates an expected call of CreateLocalGatewayRouteRequest +func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteRequest), arg0) +} + +// CreateLocalGatewayRouteTableVpcAssociation mocks base method +func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociation(arg0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociation", arg0) + ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLocalGatewayRouteTableVpcAssociation indicates an expected call of CreateLocalGatewayRouteTableVpcAssociation +func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociation), arg0) +} + +// CreateLocalGatewayRouteTableVpcAssociationRequest mocks base method +func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) + return ret0, ret1 +} + +// CreateLocalGatewayRouteTableVpcAssociationRequest indicates an expected call of CreateLocalGatewayRouteTableVpcAssociationRequest +func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociationRequest), arg0) +} + +// CreateLocalGatewayRouteTableVpcAssociationWithContext mocks base method +func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociationWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLocalGatewayRouteTableVpcAssociationWithContext indicates an expected call of CreateLocalGatewayRouteTableVpcAssociationWithContext +func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociationWithContext), varargs...) +} + +// CreateLocalGatewayRouteWithContext mocks base method +func (m *MockEC2API) CreateLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateLocalGatewayRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLocalGatewayRouteWithContext indicates an expected call of CreateLocalGatewayRouteWithContext +func (mr *MockEC2APIMockRecorder) CreateLocalGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteWithContext), varargs...) +} + +// CreateManagedPrefixList mocks base method +func (m *MockEC2API) CreateManagedPrefixList(arg0 *ec2.CreateManagedPrefixListInput) (*ec2.CreateManagedPrefixListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateManagedPrefixList", arg0) + ret0, _ := ret[0].(*ec2.CreateManagedPrefixListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateManagedPrefixList indicates an expected call of CreateManagedPrefixList +func (mr *MockEC2APIMockRecorder) CreateManagedPrefixList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).CreateManagedPrefixList), arg0) +} + +// CreateManagedPrefixListRequest mocks base method +func (m *MockEC2API) CreateManagedPrefixListRequest(arg0 *ec2.CreateManagedPrefixListInput) (*request.Request, *ec2.CreateManagedPrefixListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateManagedPrefixListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateManagedPrefixListOutput) + return ret0, ret1 +} + +// CreateManagedPrefixListRequest indicates an expected call of CreateManagedPrefixListRequest +func (mr *MockEC2APIMockRecorder) CreateManagedPrefixListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).CreateManagedPrefixListRequest), arg0) +} + +// CreateManagedPrefixListWithContext mocks base method +func (m *MockEC2API) CreateManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.CreateManagedPrefixListInput, arg2 ...request.Option) (*ec2.CreateManagedPrefixListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateManagedPrefixListWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateManagedPrefixListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateManagedPrefixListWithContext indicates an expected call of CreateManagedPrefixListWithContext +func (mr *MockEC2APIMockRecorder) CreateManagedPrefixListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixListWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateManagedPrefixListWithContext), varargs...) +} + +// CreateNatGateway mocks base method +func (m *MockEC2API) CreateNatGateway(arg0 *ec2.CreateNatGatewayInput) (*ec2.CreateNatGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNatGateway", arg0) + ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNatGateway indicates an expected call of CreateNatGateway +func (mr *MockEC2APIMockRecorder) CreateNatGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGateway", reflect.TypeOf((*MockEC2API)(nil).CreateNatGateway), arg0) +} + +// CreateNatGatewayRequest mocks base method +func (m *MockEC2API) CreateNatGatewayRequest(arg0 *ec2.CreateNatGatewayInput) (*request.Request, *ec2.CreateNatGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNatGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateNatGatewayOutput) + return ret0, ret1 +} + +// CreateNatGatewayRequest indicates an expected call of CreateNatGatewayRequest +func (mr *MockEC2APIMockRecorder) CreateNatGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNatGatewayRequest), arg0) +} + +// CreateNatGatewayWithContext mocks base method +func (m *MockEC2API) CreateNatGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateNatGatewayInput, arg2 ...request.Option) (*ec2.CreateNatGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateNatGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNatGatewayWithContext indicates an expected call of CreateNatGatewayWithContext +func (mr *MockEC2APIMockRecorder) CreateNatGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNatGatewayWithContext), varargs...) +} + +// CreateNetworkAcl mocks base method +func (m *MockEC2API) CreateNetworkAcl(arg0 *ec2.CreateNetworkAclInput) (*ec2.CreateNetworkAclOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkAcl", arg0) + ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkAcl indicates an expected call of CreateNetworkAcl +func (mr *MockEC2APIMockRecorder) CreateNetworkAcl(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAcl), arg0) +} + +// CreateNetworkAclEntry mocks base method +func (m *MockEC2API) CreateNetworkAclEntry(arg0 *ec2.CreateNetworkAclEntryInput) (*ec2.CreateNetworkAclEntryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkAclEntry", arg0) + ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkAclEntry indicates an expected call of CreateNetworkAclEntry +func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntry(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntry), arg0) +} + +// CreateNetworkAclEntryRequest mocks base method +func (m *MockEC2API) CreateNetworkAclEntryRequest(arg0 *ec2.CreateNetworkAclEntryInput) (*request.Request, *ec2.CreateNetworkAclEntryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkAclEntryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateNetworkAclEntryOutput) + return ret0, ret1 +} + +// CreateNetworkAclEntryRequest indicates an expected call of CreateNetworkAclEntryRequest +func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntryRequest), arg0) +} + +// CreateNetworkAclEntryWithContext mocks base method +func (m *MockEC2API) CreateNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkAclEntryInput, arg2 ...request.Option) (*ec2.CreateNetworkAclEntryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateNetworkAclEntryWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkAclEntryWithContext indicates an expected call of CreateNetworkAclEntryWithContext +func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntryWithContext), varargs...) +} + +// CreateNetworkAclRequest mocks base method +func (m *MockEC2API) CreateNetworkAclRequest(arg0 *ec2.CreateNetworkAclInput) (*request.Request, *ec2.CreateNetworkAclOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkAclRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateNetworkAclOutput) + return ret0, ret1 +} + +// CreateNetworkAclRequest indicates an expected call of CreateNetworkAclRequest +func (mr *MockEC2APIMockRecorder) CreateNetworkAclRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclRequest), arg0) +} + +// CreateNetworkAclWithContext mocks base method +func (m *MockEC2API) CreateNetworkAclWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkAclInput, arg2 ...request.Option) (*ec2.CreateNetworkAclOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateNetworkAclWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkAclWithContext indicates an expected call of CreateNetworkAclWithContext +func (mr *MockEC2APIMockRecorder) CreateNetworkAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclWithContext), varargs...) +} + +// CreateNetworkInterface mocks base method +func (m *MockEC2API) CreateNetworkInterface(arg0 *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkInterface", arg0) + ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkInterface indicates an expected call of CreateNetworkInterface +func (mr *MockEC2APIMockRecorder) CreateNetworkInterface(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterface), arg0) +} + +// CreateNetworkInterfacePermission mocks base method +func (m *MockEC2API) CreateNetworkInterfacePermission(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*ec2.CreateNetworkInterfacePermissionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkInterfacePermission", arg0) + ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkInterfacePermission indicates an expected call of CreateNetworkInterfacePermission +func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermission(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermission), arg0) +} + +// CreateNetworkInterfacePermissionRequest mocks base method +func (m *MockEC2API) CreateNetworkInterfacePermissionRequest(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*request.Request, *ec2.CreateNetworkInterfacePermissionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateNetworkInterfacePermissionOutput) + return ret0, ret1 +} + +// CreateNetworkInterfacePermissionRequest indicates an expected call of CreateNetworkInterfacePermissionRequest +func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermissionRequest), arg0) +} + +// CreateNetworkInterfacePermissionWithContext mocks base method +func (m *MockEC2API) CreateNetworkInterfacePermissionWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfacePermissionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkInterfacePermissionWithContext indicates an expected call of CreateNetworkInterfacePermissionWithContext +func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermissionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermissionWithContext), varargs...) +} + +// CreateNetworkInterfaceRequest mocks base method +func (m *MockEC2API) CreateNetworkInterfaceRequest(arg0 *ec2.CreateNetworkInterfaceInput) (*request.Request, *ec2.CreateNetworkInterfaceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateNetworkInterfaceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateNetworkInterfaceOutput) + return ret0, ret1 +} + +// CreateNetworkInterfaceRequest indicates an expected call of CreateNetworkInterfaceRequest +func (mr *MockEC2APIMockRecorder) CreateNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfaceRequest), arg0) +} + +// CreateNetworkInterfaceWithContext mocks base method +func (m *MockEC2API) CreateNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInterfaceInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfaceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateNetworkInterfaceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateNetworkInterfaceWithContext indicates an expected call of CreateNetworkInterfaceWithContext +func (mr *MockEC2APIMockRecorder) CreateNetworkInterfaceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfaceWithContext), varargs...) +} + +// CreatePlacementGroup mocks base method +func (m *MockEC2API) CreatePlacementGroup(arg0 *ec2.CreatePlacementGroupInput) (*ec2.CreatePlacementGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePlacementGroup", arg0) + ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePlacementGroup indicates an expected call of CreatePlacementGroup +func (mr *MockEC2APIMockRecorder) CreatePlacementGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroup), arg0) +} + +// CreatePlacementGroupRequest mocks base method +func (m *MockEC2API) CreatePlacementGroupRequest(arg0 *ec2.CreatePlacementGroupInput) (*request.Request, *ec2.CreatePlacementGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePlacementGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreatePlacementGroupOutput) + return ret0, ret1 +} + +// CreatePlacementGroupRequest indicates an expected call of CreatePlacementGroupRequest +func (mr *MockEC2APIMockRecorder) CreatePlacementGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupRequest), arg0) +} + +// CreatePlacementGroupWithContext mocks base method +func (m *MockEC2API) CreatePlacementGroupWithContext(arg0 context.Context, arg1 *ec2.CreatePlacementGroupInput, arg2 ...request.Option) (*ec2.CreatePlacementGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePlacementGroupWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePlacementGroupWithContext indicates an expected call of CreatePlacementGroupWithContext +func (mr *MockEC2APIMockRecorder) CreatePlacementGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupWithContext), varargs...) +} + +// CreateReservedInstancesListing mocks base method +func (m *MockEC2API) CreateReservedInstancesListing(arg0 *ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateReservedInstancesListing", arg0) + ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateReservedInstancesListing indicates an expected call of CreateReservedInstancesListing +func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListing(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListing), arg0) +} + +// CreateReservedInstancesListingRequest mocks base method +func (m *MockEC2API) CreateReservedInstancesListingRequest(arg0 *ec2.CreateReservedInstancesListingInput) (*request.Request, *ec2.CreateReservedInstancesListingOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateReservedInstancesListingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateReservedInstancesListingOutput) + return ret0, ret1 +} + +// CreateReservedInstancesListingRequest indicates an expected call of CreateReservedInstancesListingRequest +func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListingRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingRequest), arg0) +} + +// CreateReservedInstancesListingWithContext mocks base method +func (m *MockEC2API) CreateReservedInstancesListingWithContext(arg0 context.Context, arg1 *ec2.CreateReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CreateReservedInstancesListingOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateReservedInstancesListingWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateReservedInstancesListingWithContext indicates an expected call of CreateReservedInstancesListingWithContext +func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingWithContext), varargs...) +} + +// CreateRoute mocks base method +func (m *MockEC2API) CreateRoute(arg0 *ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRoute", arg0) + ret0, _ := ret[0].(*ec2.CreateRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRoute indicates an expected call of CreateRoute +func (mr *MockEC2APIMockRecorder) CreateRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockEC2API)(nil).CreateRoute), arg0) +} + +// CreateRouteRequest mocks base method +func (m *MockEC2API) CreateRouteRequest(arg0 *ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateRouteOutput) + return ret0, ret1 +} + +// CreateRouteRequest indicates an expected call of CreateRouteRequest +func (mr *MockEC2APIMockRecorder) CreateRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteRequest), arg0) +} + +// CreateRouteTable mocks base method +func (m *MockEC2API) CreateRouteTable(arg0 *ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRouteTable", arg0) + ret0, _ := ret[0].(*ec2.CreateRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRouteTable indicates an expected call of CreateRouteTable +func (mr *MockEC2APIMockRecorder) CreateRouteTable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTable), arg0) +} + +// CreateRouteTableRequest mocks base method +func (m *MockEC2API) CreateRouteTableRequest(arg0 *ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRouteTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateRouteTableOutput) + return ret0, ret1 +} + +// CreateRouteTableRequest indicates an expected call of CreateRouteTableRequest +func (mr *MockEC2APIMockRecorder) CreateRouteTableRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTableRequest), arg0) +} + +// CreateRouteTableWithContext mocks base method +func (m *MockEC2API) CreateRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateRouteTableInput, arg2 ...request.Option) (*ec2.CreateRouteTableOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRouteTableWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRouteTableWithContext indicates an expected call of CreateRouteTableWithContext +func (mr *MockEC2APIMockRecorder) CreateRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTableWithContext), varargs...) +} + +// CreateRouteWithContext mocks base method +func (m *MockEC2API) CreateRouteWithContext(arg0 context.Context, arg1 *ec2.CreateRouteInput, arg2 ...request.Option) (*ec2.CreateRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRouteWithContext indicates an expected call of CreateRouteWithContext +func (mr *MockEC2APIMockRecorder) CreateRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateRouteWithContext), varargs...) +} + +// CreateSecurityGroup mocks base method +func (m *MockEC2API) CreateSecurityGroup(arg0 *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSecurityGroup", arg0) + ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSecurityGroup indicates an expected call of CreateSecurityGroup +func (mr *MockEC2APIMockRecorder) CreateSecurityGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroup), arg0) +} + +// CreateSecurityGroupRequest mocks base method +func (m *MockEC2API) CreateSecurityGroupRequest(arg0 *ec2.CreateSecurityGroupInput) (*request.Request, *ec2.CreateSecurityGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSecurityGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateSecurityGroupOutput) + return ret0, ret1 +} + +// CreateSecurityGroupRequest indicates an expected call of CreateSecurityGroupRequest +func (mr *MockEC2APIMockRecorder) CreateSecurityGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroupRequest), arg0) +} + +// CreateSecurityGroupWithContext mocks base method +func (m *MockEC2API) CreateSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.CreateSecurityGroupInput, arg2 ...request.Option) (*ec2.CreateSecurityGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateSecurityGroupWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSecurityGroupWithContext indicates an expected call of CreateSecurityGroupWithContext +func (mr *MockEC2APIMockRecorder) CreateSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroupWithContext), varargs...) +} + +// CreateSnapshot mocks base method +func (m *MockEC2API) CreateSnapshot(arg0 *ec2.CreateSnapshotInput) (*ec2.Snapshot, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSnapshot", arg0) + ret0, _ := ret[0].(*ec2.Snapshot) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSnapshot indicates an expected call of CreateSnapshot +func (mr *MockEC2APIMockRecorder) CreateSnapshot(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshot), arg0) +} + +// CreateSnapshotRequest mocks base method +func (m *MockEC2API) CreateSnapshotRequest(arg0 *ec2.CreateSnapshotInput) (*request.Request, *ec2.Snapshot) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSnapshotRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.Snapshot) + return ret0, ret1 +} + +// CreateSnapshotRequest indicates an expected call of CreateSnapshotRequest +func (mr *MockEC2APIMockRecorder) CreateSnapshotRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotRequest), arg0) +} + +// CreateSnapshotWithContext mocks base method +func (m *MockEC2API) CreateSnapshotWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotInput, arg2 ...request.Option) (*ec2.Snapshot, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateSnapshotWithContext", varargs...) + ret0, _ := ret[0].(*ec2.Snapshot) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSnapshotWithContext indicates an expected call of CreateSnapshotWithContext +func (mr *MockEC2APIMockRecorder) CreateSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotWithContext), varargs...) +} + +// CreateSnapshots mocks base method +func (m *MockEC2API) CreateSnapshots(arg0 *ec2.CreateSnapshotsInput) (*ec2.CreateSnapshotsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSnapshots", arg0) + ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSnapshots indicates an expected call of CreateSnapshots +func (mr *MockEC2APIMockRecorder) CreateSnapshots(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshots", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshots), arg0) +} + +// CreateSnapshotsRequest mocks base method +func (m *MockEC2API) CreateSnapshotsRequest(arg0 *ec2.CreateSnapshotsInput) (*request.Request, *ec2.CreateSnapshotsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSnapshotsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateSnapshotsOutput) + return ret0, ret1 +} + +// CreateSnapshotsRequest indicates an expected call of CreateSnapshotsRequest +func (mr *MockEC2APIMockRecorder) CreateSnapshotsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotsRequest), arg0) +} + +// CreateSnapshotsWithContext mocks base method +func (m *MockEC2API) CreateSnapshotsWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotsInput, arg2 ...request.Option) (*ec2.CreateSnapshotsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateSnapshotsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSnapshotsWithContext indicates an expected call of CreateSnapshotsWithContext +func (mr *MockEC2APIMockRecorder) CreateSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotsWithContext), varargs...) +} + +// CreateSpotDatafeedSubscription mocks base method +func (m *MockEC2API) CreateSpotDatafeedSubscription(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscription", arg0) + ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSpotDatafeedSubscription indicates an expected call of CreateSpotDatafeedSubscription +func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscription), arg0) +} + +// CreateSpotDatafeedSubscriptionRequest mocks base method +func (m *MockEC2API) CreateSpotDatafeedSubscriptionRequest(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*request.Request, *ec2.CreateSpotDatafeedSubscriptionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateSpotDatafeedSubscriptionOutput) + return ret0, ret1 +} + +// CreateSpotDatafeedSubscriptionRequest indicates an expected call of CreateSpotDatafeedSubscriptionRequest +func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionRequest), arg0) +} + +// CreateSpotDatafeedSubscriptionWithContext mocks base method +func (m *MockEC2API) CreateSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.CreateSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSpotDatafeedSubscriptionWithContext indicates an expected call of CreateSpotDatafeedSubscriptionWithContext +func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionWithContext), varargs...) +} + +// CreateSubnet mocks base method +func (m *MockEC2API) CreateSubnet(arg0 *ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSubnet", arg0) + ret0, _ := ret[0].(*ec2.CreateSubnetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSubnet indicates an expected call of CreateSubnet +func (mr *MockEC2APIMockRecorder) CreateSubnet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateSubnet), arg0) +} + +// CreateSubnetRequest mocks base method +func (m *MockEC2API) CreateSubnetRequest(arg0 *ec2.CreateSubnetInput) (*request.Request, *ec2.CreateSubnetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSubnetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateSubnetOutput) + return ret0, ret1 +} + +// CreateSubnetRequest indicates an expected call of CreateSubnetRequest +func (mr *MockEC2APIMockRecorder) CreateSubnetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetRequest), arg0) +} + +// CreateSubnetWithContext mocks base method +func (m *MockEC2API) CreateSubnetWithContext(arg0 context.Context, arg1 *ec2.CreateSubnetInput, arg2 ...request.Option) (*ec2.CreateSubnetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateSubnetWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateSubnetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSubnetWithContext indicates an expected call of CreateSubnetWithContext +func (mr *MockEC2APIMockRecorder) CreateSubnetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetWithContext), varargs...) +} + +// CreateTags mocks base method +func (m *MockEC2API) CreateTags(arg0 *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTags", arg0) + ret0, _ := ret[0].(*ec2.CreateTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTags indicates an expected call of CreateTags +func (mr *MockEC2APIMockRecorder) CreateTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2API)(nil).CreateTags), arg0) +} + +// CreateTagsRequest mocks base method +func (m *MockEC2API) CreateTagsRequest(arg0 *ec2.CreateTagsInput) (*request.Request, *ec2.CreateTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTagsOutput) + return ret0, ret1 +} + +// CreateTagsRequest indicates an expected call of CreateTagsRequest +func (mr *MockEC2APIMockRecorder) CreateTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTagsRequest), arg0) +} + +// CreateTagsWithContext mocks base method +func (m *MockEC2API) CreateTagsWithContext(arg0 context.Context, arg1 *ec2.CreateTagsInput, arg2 ...request.Option) (*ec2.CreateTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTagsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTagsWithContext indicates an expected call of CreateTagsWithContext +func (mr *MockEC2APIMockRecorder) CreateTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTagsWithContext), varargs...) +} + +// CreateTrafficMirrorFilter mocks base method +func (m *MockEC2API) CreateTrafficMirrorFilter(arg0 *ec2.CreateTrafficMirrorFilterInput) (*ec2.CreateTrafficMirrorFilterOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficMirrorFilter", arg0) + ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficMirrorFilter indicates an expected call of CreateTrafficMirrorFilter +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilter(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilter), arg0) +} + +// CreateTrafficMirrorFilterRequest mocks base method +func (m *MockEC2API) CreateTrafficMirrorFilterRequest(arg0 *ec2.CreateTrafficMirrorFilterInput) (*request.Request, *ec2.CreateTrafficMirrorFilterOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterOutput) + return ret0, ret1 +} + +// CreateTrafficMirrorFilterRequest indicates an expected call of CreateTrafficMirrorFilterRequest +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRequest), arg0) +} + +// CreateTrafficMirrorFilterRule mocks base method +func (m *MockEC2API) CreateTrafficMirrorFilterRule(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRule", arg0) + ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficMirrorFilterRule indicates an expected call of CreateTrafficMirrorFilterRule +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRule), arg0) +} + +// CreateTrafficMirrorFilterRuleRequest mocks base method +func (m *MockEC2API) CreateTrafficMirrorFilterRuleRequest(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*request.Request, *ec2.CreateTrafficMirrorFilterRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterRuleOutput) + return ret0, ret1 +} + +// CreateTrafficMirrorFilterRuleRequest indicates an expected call of CreateTrafficMirrorFilterRuleRequest +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleRequest), arg0) +} + +// CreateTrafficMirrorFilterRuleWithContext mocks base method +func (m *MockEC2API) CreateTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficMirrorFilterRuleWithContext indicates an expected call of CreateTrafficMirrorFilterRuleWithContext +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleWithContext), varargs...) +} + +// CreateTrafficMirrorFilterWithContext mocks base method +func (m *MockEC2API) CreateTrafficMirrorFilterWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficMirrorFilterWithContext indicates an expected call of CreateTrafficMirrorFilterWithContext +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterWithContext), varargs...) +} + +// CreateTrafficMirrorSession mocks base method +func (m *MockEC2API) CreateTrafficMirrorSession(arg0 *ec2.CreateTrafficMirrorSessionInput) (*ec2.CreateTrafficMirrorSessionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficMirrorSession", arg0) + ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficMirrorSession indicates an expected call of CreateTrafficMirrorSession +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSession(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSession), arg0) +} + +// CreateTrafficMirrorSessionRequest mocks base method +func (m *MockEC2API) CreateTrafficMirrorSessionRequest(arg0 *ec2.CreateTrafficMirrorSessionInput) (*request.Request, *ec2.CreateTrafficMirrorSessionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTrafficMirrorSessionOutput) + return ret0, ret1 +} + +// CreateTrafficMirrorSessionRequest indicates an expected call of CreateTrafficMirrorSessionRequest +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionRequest), arg0) +} + +// CreateTrafficMirrorSessionWithContext mocks base method +func (m *MockEC2API) CreateTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorSessionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficMirrorSessionWithContext indicates an expected call of CreateTrafficMirrorSessionWithContext +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionWithContext), varargs...) +} + +// CreateTrafficMirrorTarget mocks base method +func (m *MockEC2API) CreateTrafficMirrorTarget(arg0 *ec2.CreateTrafficMirrorTargetInput) (*ec2.CreateTrafficMirrorTargetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficMirrorTarget", arg0) + ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficMirrorTarget indicates an expected call of CreateTrafficMirrorTarget +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTarget(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTarget), arg0) +} + +// CreateTrafficMirrorTargetRequest mocks base method +func (m *MockEC2API) CreateTrafficMirrorTargetRequest(arg0 *ec2.CreateTrafficMirrorTargetInput) (*request.Request, *ec2.CreateTrafficMirrorTargetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTrafficMirrorTargetOutput) + return ret0, ret1 +} + +// CreateTrafficMirrorTargetRequest indicates an expected call of CreateTrafficMirrorTargetRequest +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetRequest), arg0) +} + +// CreateTrafficMirrorTargetWithContext mocks base method +func (m *MockEC2API) CreateTrafficMirrorTargetWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorTargetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTrafficMirrorTargetWithContext indicates an expected call of CreateTrafficMirrorTargetWithContext +func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetWithContext), varargs...) +} + +// CreateTransitGateway mocks base method +func (m *MockEC2API) CreateTransitGateway(arg0 *ec2.CreateTransitGatewayInput) (*ec2.CreateTransitGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGateway", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGateway indicates an expected call of CreateTransitGateway +func (mr *MockEC2APIMockRecorder) CreateTransitGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGateway", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGateway), arg0) +} + +// CreateTransitGatewayMulticastDomain mocks base method +func (m *MockEC2API) CreateTransitGatewayMulticastDomain(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomain", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayMulticastDomain indicates an expected call of CreateTransitGatewayMulticastDomain +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomain), arg0) +} + +// CreateTransitGatewayMulticastDomainRequest mocks base method +func (m *MockEC2API) CreateTransitGatewayMulticastDomainRequest(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.CreateTransitGatewayMulticastDomainOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayMulticastDomainOutput) + return ret0, ret1 +} + +// CreateTransitGatewayMulticastDomainRequest indicates an expected call of CreateTransitGatewayMulticastDomainRequest +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainRequest), arg0) +} + +// CreateTransitGatewayMulticastDomainWithContext mocks base method +func (m *MockEC2API) CreateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayMulticastDomainWithContext indicates an expected call of CreateTransitGatewayMulticastDomainWithContext +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainWithContext), varargs...) +} + +// CreateTransitGatewayPeeringAttachment mocks base method +func (m *MockEC2API) CreateTransitGatewayPeeringAttachment(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachment", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayPeeringAttachment indicates an expected call of CreateTransitGatewayPeeringAttachment +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachment), arg0) +} + +// CreateTransitGatewayPeeringAttachmentRequest mocks base method +func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentRequest(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayPeeringAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) + return ret0, ret1 +} + +// CreateTransitGatewayPeeringAttachmentRequest indicates an expected call of CreateTransitGatewayPeeringAttachmentRequest +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentRequest), arg0) +} + +// CreateTransitGatewayPeeringAttachmentWithContext mocks base method +func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayPeeringAttachmentWithContext indicates an expected call of CreateTransitGatewayPeeringAttachmentWithContext +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentWithContext), varargs...) +} + +// CreateTransitGatewayPrefixListReference mocks base method +func (m *MockEC2API) CreateTransitGatewayPrefixListReference(arg0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReference", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayPrefixListReferenceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayPrefixListReference indicates an expected call of CreateTransitGatewayPrefixListReference +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPrefixListReference), arg0) +} + +// CreateTransitGatewayPrefixListReferenceRequest mocks base method +func (m *MockEC2API) CreateTransitGatewayPrefixListReferenceRequest(arg0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.CreateTransitGatewayPrefixListReferenceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReferenceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayPrefixListReferenceOutput) + return ret0, ret1 +} + +// CreateTransitGatewayPrefixListReferenceRequest indicates an expected call of CreateTransitGatewayPrefixListReferenceRequest +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPrefixListReferenceRequest), arg0) +} + +// CreateTransitGatewayPrefixListReferenceWithContext mocks base method +func (m *MockEC2API) CreateTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReferenceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayPrefixListReferenceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayPrefixListReferenceWithContext indicates an expected call of CreateTransitGatewayPrefixListReferenceWithContext +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPrefixListReferenceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPrefixListReferenceWithContext), varargs...) +} + +// CreateTransitGatewayRequest mocks base method +func (m *MockEC2API) CreateTransitGatewayRequest(arg0 *ec2.CreateTransitGatewayInput) (*request.Request, *ec2.CreateTransitGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayOutput) + return ret0, ret1 +} + +// CreateTransitGatewayRequest indicates an expected call of CreateTransitGatewayRequest +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRequest), arg0) +} + +// CreateTransitGatewayRoute mocks base method +func (m *MockEC2API) CreateTransitGatewayRoute(arg0 *ec2.CreateTransitGatewayRouteInput) (*ec2.CreateTransitGatewayRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayRoute", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayRoute indicates an expected call of CreateTransitGatewayRoute +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRoute), arg0) +} + +// CreateTransitGatewayRouteRequest mocks base method +func (m *MockEC2API) CreateTransitGatewayRouteRequest(arg0 *ec2.CreateTransitGatewayRouteInput) (*request.Request, *ec2.CreateTransitGatewayRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteOutput) + return ret0, ret1 +} + +// CreateTransitGatewayRouteRequest indicates an expected call of CreateTransitGatewayRouteRequest +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteRequest), arg0) +} + +// CreateTransitGatewayRouteTable mocks base method +func (m *MockEC2API) CreateTransitGatewayRouteTable(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*ec2.CreateTransitGatewayRouteTableOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTable", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayRouteTable indicates an expected call of CreateTransitGatewayRouteTable +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTable), arg0) +} + +// CreateTransitGatewayRouteTableRequest mocks base method +func (m *MockEC2API) CreateTransitGatewayRouteTableRequest(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableOutput) + return ret0, ret1 +} + +// CreateTransitGatewayRouteTableRequest indicates an expected call of CreateTransitGatewayRouteTableRequest +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableRequest), arg0) +} + +// CreateTransitGatewayRouteTableWithContext mocks base method +func (m *MockEC2API) CreateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayRouteTableWithContext indicates an expected call of CreateTransitGatewayRouteTableWithContext +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableWithContext), varargs...) +} + +// CreateTransitGatewayRouteWithContext mocks base method +func (m *MockEC2API) CreateTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayRouteWithContext indicates an expected call of CreateTransitGatewayRouteWithContext +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteWithContext), varargs...) +} + +// CreateTransitGatewayVpcAttachment mocks base method +func (m *MockEC2API) CreateTransitGatewayVpcAttachment(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachment", arg0) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayVpcAttachment indicates an expected call of CreateTransitGatewayVpcAttachment +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachment), arg0) +} + +// CreateTransitGatewayVpcAttachmentRequest mocks base method +func (m *MockEC2API) CreateTransitGatewayVpcAttachmentRequest(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayVpcAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateTransitGatewayVpcAttachmentOutput) + return ret0, ret1 +} + +// CreateTransitGatewayVpcAttachmentRequest indicates an expected call of CreateTransitGatewayVpcAttachmentRequest +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentRequest), arg0) +} + +// CreateTransitGatewayVpcAttachmentWithContext mocks base method +func (m *MockEC2API) CreateTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayVpcAttachmentWithContext indicates an expected call of CreateTransitGatewayVpcAttachmentWithContext +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentWithContext), varargs...) +} + +// CreateTransitGatewayWithContext mocks base method +func (m *MockEC2API) CreateTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateTransitGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTransitGatewayWithContext indicates an expected call of CreateTransitGatewayWithContext +func (mr *MockEC2APIMockRecorder) CreateTransitGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayWithContext), varargs...) +} + +// CreateVolume mocks base method +func (m *MockEC2API) CreateVolume(arg0 *ec2.CreateVolumeInput) (*ec2.Volume, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVolume", arg0) + ret0, _ := ret[0].(*ec2.Volume) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVolume indicates an expected call of CreateVolume +func (mr *MockEC2APIMockRecorder) CreateVolume(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockEC2API)(nil).CreateVolume), arg0) +} + +// CreateVolumeRequest mocks base method +func (m *MockEC2API) CreateVolumeRequest(arg0 *ec2.CreateVolumeInput) (*request.Request, *ec2.Volume) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVolumeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.Volume) + return ret0, ret1 +} + +// CreateVolumeRequest indicates an expected call of CreateVolumeRequest +func (mr *MockEC2APIMockRecorder) CreateVolumeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVolumeRequest), arg0) +} + +// CreateVolumeWithContext mocks base method +func (m *MockEC2API) CreateVolumeWithContext(arg0 context.Context, arg1 *ec2.CreateVolumeInput, arg2 ...request.Option) (*ec2.Volume, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVolumeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.Volume) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVolumeWithContext indicates an expected call of CreateVolumeWithContext +func (mr *MockEC2APIMockRecorder) CreateVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVolumeWithContext), varargs...) +} + +// CreateVpc mocks base method +func (m *MockEC2API) CreateVpc(arg0 *ec2.CreateVpcInput) (*ec2.CreateVpcOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpc", arg0) + ret0, _ := ret[0].(*ec2.CreateVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpc indicates an expected call of CreateVpc +func (mr *MockEC2APIMockRecorder) CreateVpc(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpc", reflect.TypeOf((*MockEC2API)(nil).CreateVpc), arg0) +} + +// CreateVpcEndpoint mocks base method +func (m *MockEC2API) CreateVpcEndpoint(arg0 *ec2.CreateVpcEndpointInput) (*ec2.CreateVpcEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcEndpoint", arg0) + ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcEndpoint indicates an expected call of CreateVpcEndpoint +func (mr *MockEC2APIMockRecorder) CreateVpcEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpoint), arg0) +} + +// CreateVpcEndpointConnectionNotification mocks base method +func (m *MockEC2API) CreateVpcEndpointConnectionNotification(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotification", arg0) + ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcEndpointConnectionNotification indicates an expected call of CreateVpcEndpointConnectionNotification +func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotification), arg0) +} + +// CreateVpcEndpointConnectionNotificationRequest mocks base method +func (m *MockEC2API) CreateVpcEndpointConnectionNotificationRequest(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.CreateVpcEndpointConnectionNotificationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateVpcEndpointConnectionNotificationOutput) + return ret0, ret1 +} + +// CreateVpcEndpointConnectionNotificationRequest indicates an expected call of CreateVpcEndpointConnectionNotificationRequest +func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationRequest), arg0) +} + +// CreateVpcEndpointConnectionNotificationWithContext mocks base method +func (m *MockEC2API) CreateVpcEndpointConnectionNotificationWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcEndpointConnectionNotificationWithContext indicates an expected call of CreateVpcEndpointConnectionNotificationWithContext +func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotificationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationWithContext), varargs...) +} + +// CreateVpcEndpointRequest mocks base method +func (m *MockEC2API) CreateVpcEndpointRequest(arg0 *ec2.CreateVpcEndpointInput) (*request.Request, *ec2.CreateVpcEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateVpcEndpointOutput) + return ret0, ret1 +} + +// CreateVpcEndpointRequest indicates an expected call of CreateVpcEndpointRequest +func (mr *MockEC2APIMockRecorder) CreateVpcEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointRequest), arg0) +} + +// CreateVpcEndpointServiceConfiguration mocks base method +func (m *MockEC2API) CreateVpcEndpointServiceConfiguration(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfiguration", arg0) + ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcEndpointServiceConfiguration indicates an expected call of CreateVpcEndpointServiceConfiguration +func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfiguration), arg0) +} + +// CreateVpcEndpointServiceConfigurationRequest mocks base method +func (m *MockEC2API) CreateVpcEndpointServiceConfigurationRequest(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.CreateVpcEndpointServiceConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateVpcEndpointServiceConfigurationOutput) + return ret0, ret1 +} + +// CreateVpcEndpointServiceConfigurationRequest indicates an expected call of CreateVpcEndpointServiceConfigurationRequest +func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationRequest), arg0) +} + +// CreateVpcEndpointServiceConfigurationWithContext mocks base method +func (m *MockEC2API) CreateVpcEndpointServiceConfigurationWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcEndpointServiceConfigurationWithContext indicates an expected call of CreateVpcEndpointServiceConfigurationWithContext +func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationWithContext), varargs...) +} + +// CreateVpcEndpointWithContext mocks base method +func (m *MockEC2API) CreateVpcEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpcEndpointWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcEndpointWithContext indicates an expected call of CreateVpcEndpointWithContext +func (mr *MockEC2APIMockRecorder) CreateVpcEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointWithContext), varargs...) +} + +// CreateVpcPeeringConnection mocks base method +func (m *MockEC2API) CreateVpcPeeringConnection(arg0 *ec2.CreateVpcPeeringConnectionInput) (*ec2.CreateVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcPeeringConnection", arg0) + ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcPeeringConnection indicates an expected call of CreateVpcPeeringConnection +func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnection), arg0) +} + +// CreateVpcPeeringConnectionRequest mocks base method +func (m *MockEC2API) CreateVpcPeeringConnectionRequest(arg0 *ec2.CreateVpcPeeringConnectionInput) (*request.Request, *ec2.CreateVpcPeeringConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateVpcPeeringConnectionOutput) + return ret0, ret1 +} + +// CreateVpcPeeringConnectionRequest indicates an expected call of CreateVpcPeeringConnectionRequest +func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnectionRequest), arg0) +} + +// CreateVpcPeeringConnectionWithContext mocks base method +func (m *MockEC2API) CreateVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.CreateVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.CreateVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcPeeringConnectionWithContext indicates an expected call of CreateVpcPeeringConnectionWithContext +func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnectionWithContext), varargs...) +} + +// CreateVpcRequest mocks base method +func (m *MockEC2API) CreateVpcRequest(arg0 *ec2.CreateVpcInput) (*request.Request, *ec2.CreateVpcOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpcRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateVpcOutput) + return ret0, ret1 +} + +// CreateVpcRequest indicates an expected call of CreateVpcRequest +func (mr *MockEC2APIMockRecorder) CreateVpcRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcRequest), arg0) +} + +// CreateVpcWithContext mocks base method +func (m *MockEC2API) CreateVpcWithContext(arg0 context.Context, arg1 *ec2.CreateVpcInput, arg2 ...request.Option) (*ec2.CreateVpcOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpcWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpcWithContext indicates an expected call of CreateVpcWithContext +func (mr *MockEC2APIMockRecorder) CreateVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcWithContext), varargs...) +} + +// CreateVpnConnection mocks base method +func (m *MockEC2API) CreateVpnConnection(arg0 *ec2.CreateVpnConnectionInput) (*ec2.CreateVpnConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpnConnection", arg0) + ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpnConnection indicates an expected call of CreateVpnConnection +func (mr *MockEC2APIMockRecorder) CreateVpnConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnection), arg0) +} + +// CreateVpnConnectionRequest mocks base method +func (m *MockEC2API) CreateVpnConnectionRequest(arg0 *ec2.CreateVpnConnectionInput) (*request.Request, *ec2.CreateVpnConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpnConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateVpnConnectionOutput) + return ret0, ret1 +} + +// CreateVpnConnectionRequest indicates an expected call of CreateVpnConnectionRequest +func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRequest), arg0) +} + +// CreateVpnConnectionRoute mocks base method +func (m *MockEC2API) CreateVpnConnectionRoute(arg0 *ec2.CreateVpnConnectionRouteInput) (*ec2.CreateVpnConnectionRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpnConnectionRoute", arg0) + ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpnConnectionRoute indicates an expected call of CreateVpnConnectionRoute +func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRoute), arg0) +} + +// CreateVpnConnectionRouteRequest mocks base method +func (m *MockEC2API) CreateVpnConnectionRouteRequest(arg0 *ec2.CreateVpnConnectionRouteInput) (*request.Request, *ec2.CreateVpnConnectionRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpnConnectionRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateVpnConnectionRouteOutput) + return ret0, ret1 +} + +// CreateVpnConnectionRouteRequest indicates an expected call of CreateVpnConnectionRouteRequest +func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRouteRequest), arg0) +} + +// CreateVpnConnectionRouteWithContext mocks base method +func (m *MockEC2API) CreateVpnConnectionRouteWithContext(arg0 context.Context, arg1 *ec2.CreateVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpnConnectionRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpnConnectionRouteWithContext indicates an expected call of CreateVpnConnectionRouteWithContext +func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRouteWithContext), varargs...) +} + +// CreateVpnConnectionWithContext mocks base method +func (m *MockEC2API) CreateVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.CreateVpnConnectionInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpnConnectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpnConnectionWithContext indicates an expected call of CreateVpnConnectionWithContext +func (mr *MockEC2APIMockRecorder) CreateVpnConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionWithContext), varargs...) +} + +// CreateVpnGateway mocks base method +func (m *MockEC2API) CreateVpnGateway(arg0 *ec2.CreateVpnGatewayInput) (*ec2.CreateVpnGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpnGateway", arg0) + ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpnGateway indicates an expected call of CreateVpnGateway +func (mr *MockEC2APIMockRecorder) CreateVpnGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGateway", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGateway), arg0) +} + +// CreateVpnGatewayRequest mocks base method +func (m *MockEC2API) CreateVpnGatewayRequest(arg0 *ec2.CreateVpnGatewayInput) (*request.Request, *ec2.CreateVpnGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVpnGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.CreateVpnGatewayOutput) + return ret0, ret1 +} + +// CreateVpnGatewayRequest indicates an expected call of CreateVpnGatewayRequest +func (mr *MockEC2APIMockRecorder) CreateVpnGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGatewayRequest), arg0) +} + +// CreateVpnGatewayWithContext mocks base method +func (m *MockEC2API) CreateVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateVpnGatewayInput, arg2 ...request.Option) (*ec2.CreateVpnGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVpnGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVpnGatewayWithContext indicates an expected call of CreateVpnGatewayWithContext +func (mr *MockEC2APIMockRecorder) CreateVpnGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGatewayWithContext), varargs...) +} + +// DeleteCarrierGateway mocks base method +func (m *MockEC2API) DeleteCarrierGateway(arg0 *ec2.DeleteCarrierGatewayInput) (*ec2.DeleteCarrierGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCarrierGateway", arg0) + ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCarrierGateway indicates an expected call of DeleteCarrierGateway +func (mr *MockEC2APIMockRecorder) DeleteCarrierGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGateway), arg0) +} + +// DeleteCarrierGatewayRequest mocks base method +func (m *MockEC2API) DeleteCarrierGatewayRequest(arg0 *ec2.DeleteCarrierGatewayInput) (*request.Request, *ec2.DeleteCarrierGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCarrierGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteCarrierGatewayOutput) + return ret0, ret1 +} + +// DeleteCarrierGatewayRequest indicates an expected call of DeleteCarrierGatewayRequest +func (mr *MockEC2APIMockRecorder) DeleteCarrierGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGatewayRequest), arg0) +} + +// DeleteCarrierGatewayWithContext mocks base method +func (m *MockEC2API) DeleteCarrierGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteCarrierGatewayInput, arg2 ...request.Option) (*ec2.DeleteCarrierGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteCarrierGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCarrierGatewayWithContext indicates an expected call of DeleteCarrierGatewayWithContext +func (mr *MockEC2APIMockRecorder) DeleteCarrierGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteCarrierGatewayWithContext), varargs...) +} + +// DeleteClientVpnEndpoint mocks base method +func (m *MockEC2API) DeleteClientVpnEndpoint(arg0 *ec2.DeleteClientVpnEndpointInput) (*ec2.DeleteClientVpnEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteClientVpnEndpoint", arg0) + ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteClientVpnEndpoint indicates an expected call of DeleteClientVpnEndpoint +func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpoint), arg0) +} + +// DeleteClientVpnEndpointRequest mocks base method +func (m *MockEC2API) DeleteClientVpnEndpointRequest(arg0 *ec2.DeleteClientVpnEndpointInput) (*request.Request, *ec2.DeleteClientVpnEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteClientVpnEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteClientVpnEndpointOutput) + return ret0, ret1 +} + +// DeleteClientVpnEndpointRequest indicates an expected call of DeleteClientVpnEndpointRequest +func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpointRequest), arg0) +} + +// DeleteClientVpnEndpointWithContext mocks base method +func (m *MockEC2API) DeleteClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteClientVpnEndpointInput, arg2 ...request.Option) (*ec2.DeleteClientVpnEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteClientVpnEndpointWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteClientVpnEndpointWithContext indicates an expected call of DeleteClientVpnEndpointWithContext +func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpointWithContext), varargs...) +} + +// DeleteClientVpnRoute mocks base method +func (m *MockEC2API) DeleteClientVpnRoute(arg0 *ec2.DeleteClientVpnRouteInput) (*ec2.DeleteClientVpnRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteClientVpnRoute", arg0) + ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteClientVpnRoute indicates an expected call of DeleteClientVpnRoute +func (mr *MockEC2APIMockRecorder) DeleteClientVpnRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRoute), arg0) +} + +// DeleteClientVpnRouteRequest mocks base method +func (m *MockEC2API) DeleteClientVpnRouteRequest(arg0 *ec2.DeleteClientVpnRouteInput) (*request.Request, *ec2.DeleteClientVpnRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteClientVpnRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteClientVpnRouteOutput) + return ret0, ret1 +} + +// DeleteClientVpnRouteRequest indicates an expected call of DeleteClientVpnRouteRequest +func (mr *MockEC2APIMockRecorder) DeleteClientVpnRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRouteRequest), arg0) +} + +// DeleteClientVpnRouteWithContext mocks base method +func (m *MockEC2API) DeleteClientVpnRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteClientVpnRouteInput, arg2 ...request.Option) (*ec2.DeleteClientVpnRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteClientVpnRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteClientVpnRouteWithContext indicates an expected call of DeleteClientVpnRouteWithContext +func (mr *MockEC2APIMockRecorder) DeleteClientVpnRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRouteWithContext), varargs...) +} + +// DeleteCustomerGateway mocks base method +func (m *MockEC2API) DeleteCustomerGateway(arg0 *ec2.DeleteCustomerGatewayInput) (*ec2.DeleteCustomerGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCustomerGateway", arg0) + ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCustomerGateway indicates an expected call of DeleteCustomerGateway +func (mr *MockEC2APIMockRecorder) DeleteCustomerGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGateway), arg0) +} + +// DeleteCustomerGatewayRequest mocks base method +func (m *MockEC2API) DeleteCustomerGatewayRequest(arg0 *ec2.DeleteCustomerGatewayInput) (*request.Request, *ec2.DeleteCustomerGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCustomerGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteCustomerGatewayOutput) + return ret0, ret1 +} + +// DeleteCustomerGatewayRequest indicates an expected call of DeleteCustomerGatewayRequest +func (mr *MockEC2APIMockRecorder) DeleteCustomerGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGatewayRequest), arg0) +} + +// DeleteCustomerGatewayWithContext mocks base method +func (m *MockEC2API) DeleteCustomerGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteCustomerGatewayInput, arg2 ...request.Option) (*ec2.DeleteCustomerGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteCustomerGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCustomerGatewayWithContext indicates an expected call of DeleteCustomerGatewayWithContext +func (mr *MockEC2APIMockRecorder) DeleteCustomerGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGatewayWithContext), varargs...) +} + +// DeleteDhcpOptions mocks base method +func (m *MockEC2API) DeleteDhcpOptions(arg0 *ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDhcpOptions", arg0) + ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDhcpOptions indicates an expected call of DeleteDhcpOptions +func (mr *MockEC2APIMockRecorder) DeleteDhcpOptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptions), arg0) +} + +// DeleteDhcpOptionsRequest mocks base method +func (m *MockEC2API) DeleteDhcpOptionsRequest(arg0 *ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDhcpOptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteDhcpOptionsOutput) + return ret0, ret1 +} + +// DeleteDhcpOptionsRequest indicates an expected call of DeleteDhcpOptionsRequest +func (mr *MockEC2APIMockRecorder) DeleteDhcpOptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptionsRequest), arg0) +} + +// DeleteDhcpOptionsWithContext mocks base method +func (m *MockEC2API) DeleteDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.DeleteDhcpOptionsInput, arg2 ...request.Option) (*ec2.DeleteDhcpOptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteDhcpOptionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDhcpOptionsWithContext indicates an expected call of DeleteDhcpOptionsWithContext +func (mr *MockEC2APIMockRecorder) DeleteDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptionsWithContext), varargs...) +} + +// DeleteEgressOnlyInternetGateway mocks base method +func (m *MockEC2API) DeleteEgressOnlyInternetGateway(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGateway", arg0) + ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteEgressOnlyInternetGateway indicates an expected call of DeleteEgressOnlyInternetGateway +func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGateway), arg0) +} + +// DeleteEgressOnlyInternetGatewayRequest mocks base method +func (m *MockEC2API) DeleteEgressOnlyInternetGatewayRequest(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*request.Request, *ec2.DeleteEgressOnlyInternetGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteEgressOnlyInternetGatewayOutput) + return ret0, ret1 +} + +// DeleteEgressOnlyInternetGatewayRequest indicates an expected call of DeleteEgressOnlyInternetGatewayRequest +func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayRequest), arg0) +} + +// DeleteEgressOnlyInternetGatewayWithContext mocks base method +func (m *MockEC2API) DeleteEgressOnlyInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteEgressOnlyInternetGatewayWithContext indicates an expected call of DeleteEgressOnlyInternetGatewayWithContext +func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayWithContext), varargs...) +} + +// DeleteFleets mocks base method +func (m *MockEC2API) DeleteFleets(arg0 *ec2.DeleteFleetsInput) (*ec2.DeleteFleetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFleets", arg0) + ret0, _ := ret[0].(*ec2.DeleteFleetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFleets indicates an expected call of DeleteFleets +func (mr *MockEC2APIMockRecorder) DeleteFleets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleets", reflect.TypeOf((*MockEC2API)(nil).DeleteFleets), arg0) +} + +// DeleteFleetsRequest mocks base method +func (m *MockEC2API) DeleteFleetsRequest(arg0 *ec2.DeleteFleetsInput) (*request.Request, *ec2.DeleteFleetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFleetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteFleetsOutput) + return ret0, ret1 +} + +// DeleteFleetsRequest indicates an expected call of DeleteFleetsRequest +func (mr *MockEC2APIMockRecorder) DeleteFleetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFleetsRequest), arg0) +} + +// DeleteFleetsWithContext mocks base method +func (m *MockEC2API) DeleteFleetsWithContext(arg0 context.Context, arg1 *ec2.DeleteFleetsInput, arg2 ...request.Option) (*ec2.DeleteFleetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteFleetsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteFleetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFleetsWithContext indicates an expected call of DeleteFleetsWithContext +func (mr *MockEC2APIMockRecorder) DeleteFleetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFleetsWithContext), varargs...) +} + +// DeleteFlowLogs mocks base method +func (m *MockEC2API) DeleteFlowLogs(arg0 *ec2.DeleteFlowLogsInput) (*ec2.DeleteFlowLogsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFlowLogs", arg0) + ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFlowLogs indicates an expected call of DeleteFlowLogs +func (mr *MockEC2APIMockRecorder) DeleteFlowLogs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogs), arg0) +} + +// DeleteFlowLogsRequest mocks base method +func (m *MockEC2API) DeleteFlowLogsRequest(arg0 *ec2.DeleteFlowLogsInput) (*request.Request, *ec2.DeleteFlowLogsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFlowLogsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteFlowLogsOutput) + return ret0, ret1 +} + +// DeleteFlowLogsRequest indicates an expected call of DeleteFlowLogsRequest +func (mr *MockEC2APIMockRecorder) DeleteFlowLogsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogsRequest), arg0) +} + +// DeleteFlowLogsWithContext mocks base method +func (m *MockEC2API) DeleteFlowLogsWithContext(arg0 context.Context, arg1 *ec2.DeleteFlowLogsInput, arg2 ...request.Option) (*ec2.DeleteFlowLogsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteFlowLogsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFlowLogsWithContext indicates an expected call of DeleteFlowLogsWithContext +func (mr *MockEC2APIMockRecorder) DeleteFlowLogsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogsWithContext), varargs...) +} + +// DeleteFpgaImage mocks base method +func (m *MockEC2API) DeleteFpgaImage(arg0 *ec2.DeleteFpgaImageInput) (*ec2.DeleteFpgaImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFpgaImage", arg0) + ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFpgaImage indicates an expected call of DeleteFpgaImage +func (mr *MockEC2APIMockRecorder) DeleteFpgaImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImage", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImage), arg0) +} + +// DeleteFpgaImageRequest mocks base method +func (m *MockEC2API) DeleteFpgaImageRequest(arg0 *ec2.DeleteFpgaImageInput) (*request.Request, *ec2.DeleteFpgaImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteFpgaImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteFpgaImageOutput) + return ret0, ret1 +} + +// DeleteFpgaImageRequest indicates an expected call of DeleteFpgaImageRequest +func (mr *MockEC2APIMockRecorder) DeleteFpgaImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImageRequest), arg0) +} + +// DeleteFpgaImageWithContext mocks base method +func (m *MockEC2API) DeleteFpgaImageWithContext(arg0 context.Context, arg1 *ec2.DeleteFpgaImageInput, arg2 ...request.Option) (*ec2.DeleteFpgaImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteFpgaImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteFpgaImageWithContext indicates an expected call of DeleteFpgaImageWithContext +func (mr *MockEC2APIMockRecorder) DeleteFpgaImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImageWithContext), varargs...) +} + +// DeleteInternetGateway mocks base method +func (m *MockEC2API) DeleteInternetGateway(arg0 *ec2.DeleteInternetGatewayInput) (*ec2.DeleteInternetGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteInternetGateway", arg0) + ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteInternetGateway indicates an expected call of DeleteInternetGateway +func (mr *MockEC2APIMockRecorder) DeleteInternetGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGateway), arg0) +} + +// DeleteInternetGatewayRequest mocks base method +func (m *MockEC2API) DeleteInternetGatewayRequest(arg0 *ec2.DeleteInternetGatewayInput) (*request.Request, *ec2.DeleteInternetGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteInternetGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteInternetGatewayOutput) + return ret0, ret1 +} + +// DeleteInternetGatewayRequest indicates an expected call of DeleteInternetGatewayRequest +func (mr *MockEC2APIMockRecorder) DeleteInternetGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGatewayRequest), arg0) +} + +// DeleteInternetGatewayWithContext mocks base method +func (m *MockEC2API) DeleteInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteInternetGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteInternetGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteInternetGatewayWithContext indicates an expected call of DeleteInternetGatewayWithContext +func (mr *MockEC2APIMockRecorder) DeleteInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGatewayWithContext), varargs...) +} + +// DeleteKeyPair mocks base method +func (m *MockEC2API) DeleteKeyPair(arg0 *ec2.DeleteKeyPairInput) (*ec2.DeleteKeyPairOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteKeyPair", arg0) + ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteKeyPair indicates an expected call of DeleteKeyPair +func (mr *MockEC2APIMockRecorder) DeleteKeyPair(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPair", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPair), arg0) +} + +// DeleteKeyPairRequest mocks base method +func (m *MockEC2API) DeleteKeyPairRequest(arg0 *ec2.DeleteKeyPairInput) (*request.Request, *ec2.DeleteKeyPairOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteKeyPairRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteKeyPairOutput) + return ret0, ret1 +} + +// DeleteKeyPairRequest indicates an expected call of DeleteKeyPairRequest +func (mr *MockEC2APIMockRecorder) DeleteKeyPairRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPairRequest), arg0) +} + +// DeleteKeyPairWithContext mocks base method +func (m *MockEC2API) DeleteKeyPairWithContext(arg0 context.Context, arg1 *ec2.DeleteKeyPairInput, arg2 ...request.Option) (*ec2.DeleteKeyPairOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteKeyPairWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteKeyPairWithContext indicates an expected call of DeleteKeyPairWithContext +func (mr *MockEC2APIMockRecorder) DeleteKeyPairWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPairWithContext), varargs...) +} + +// DeleteLaunchTemplate mocks base method +func (m *MockEC2API) DeleteLaunchTemplate(arg0 *ec2.DeleteLaunchTemplateInput) (*ec2.DeleteLaunchTemplateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLaunchTemplate", arg0) + ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLaunchTemplate indicates an expected call of DeleteLaunchTemplate +func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplate), arg0) +} + +// DeleteLaunchTemplateRequest mocks base method +func (m *MockEC2API) DeleteLaunchTemplateRequest(arg0 *ec2.DeleteLaunchTemplateInput) (*request.Request, *ec2.DeleteLaunchTemplateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLaunchTemplateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateOutput) + return ret0, ret1 +} + +// DeleteLaunchTemplateRequest indicates an expected call of DeleteLaunchTemplateRequest +func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateRequest), arg0) +} + +// DeleteLaunchTemplateVersions mocks base method +func (m *MockEC2API) DeleteLaunchTemplateVersions(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*ec2.DeleteLaunchTemplateVersionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersions", arg0) + ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLaunchTemplateVersions indicates an expected call of DeleteLaunchTemplateVersions +func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersions), arg0) +} + +// DeleteLaunchTemplateVersionsRequest mocks base method +func (m *MockEC2API) DeleteLaunchTemplateVersionsRequest(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*request.Request, *ec2.DeleteLaunchTemplateVersionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateVersionsOutput) + return ret0, ret1 +} + +// DeleteLaunchTemplateVersionsRequest indicates an expected call of DeleteLaunchTemplateVersionsRequest +func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersionsRequest), arg0) +} + +// DeleteLaunchTemplateVersionsWithContext mocks base method +func (m *MockEC2API) DeleteLaunchTemplateVersionsWithContext(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateVersionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLaunchTemplateVersionsWithContext indicates an expected call of DeleteLaunchTemplateVersionsWithContext +func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersionsWithContext), varargs...) +} + +// DeleteLaunchTemplateWithContext mocks base method +func (m *MockEC2API) DeleteLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLaunchTemplateWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLaunchTemplateWithContext indicates an expected call of DeleteLaunchTemplateWithContext +func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateWithContext), varargs...) +} + +// DeleteLocalGatewayRoute mocks base method +func (m *MockEC2API) DeleteLocalGatewayRoute(arg0 *ec2.DeleteLocalGatewayRouteInput) (*ec2.DeleteLocalGatewayRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLocalGatewayRoute", arg0) + ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLocalGatewayRoute indicates an expected call of DeleteLocalGatewayRoute +func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRoute), arg0) +} + +// DeleteLocalGatewayRouteRequest mocks base method +func (m *MockEC2API) DeleteLocalGatewayRouteRequest(arg0 *ec2.DeleteLocalGatewayRouteInput) (*request.Request, *ec2.DeleteLocalGatewayRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteOutput) + return ret0, ret1 +} + +// DeleteLocalGatewayRouteRequest indicates an expected call of DeleteLocalGatewayRouteRequest +func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteRequest), arg0) +} + +// DeleteLocalGatewayRouteTableVpcAssociation mocks base method +func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociation(arg0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociation", arg0) + ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLocalGatewayRouteTableVpcAssociation indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociation +func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociation), arg0) +} + +// DeleteLocalGatewayRouteTableVpcAssociationRequest mocks base method +func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) + return ret0, ret1 +} + +// DeleteLocalGatewayRouteTableVpcAssociationRequest indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociationRequest +func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociationRequest), arg0) +} + +// DeleteLocalGatewayRouteTableVpcAssociationWithContext mocks base method +func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociationWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLocalGatewayRouteTableVpcAssociationWithContext indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociationWithContext +func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociationWithContext), varargs...) +} + +// DeleteLocalGatewayRouteWithContext mocks base method +func (m *MockEC2API) DeleteLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLocalGatewayRouteWithContext indicates an expected call of DeleteLocalGatewayRouteWithContext +func (mr *MockEC2APIMockRecorder) DeleteLocalGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteWithContext), varargs...) +} + +// DeleteManagedPrefixList mocks base method +func (m *MockEC2API) DeleteManagedPrefixList(arg0 *ec2.DeleteManagedPrefixListInput) (*ec2.DeleteManagedPrefixListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteManagedPrefixList", arg0) + ret0, _ := ret[0].(*ec2.DeleteManagedPrefixListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteManagedPrefixList indicates an expected call of DeleteManagedPrefixList +func (mr *MockEC2APIMockRecorder) DeleteManagedPrefixList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).DeleteManagedPrefixList), arg0) +} + +// DeleteManagedPrefixListRequest mocks base method +func (m *MockEC2API) DeleteManagedPrefixListRequest(arg0 *ec2.DeleteManagedPrefixListInput) (*request.Request, *ec2.DeleteManagedPrefixListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteManagedPrefixListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteManagedPrefixListOutput) + return ret0, ret1 +} + +// DeleteManagedPrefixListRequest indicates an expected call of DeleteManagedPrefixListRequest +func (mr *MockEC2APIMockRecorder) DeleteManagedPrefixListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteManagedPrefixListRequest), arg0) +} + +// DeleteManagedPrefixListWithContext mocks base method +func (m *MockEC2API) DeleteManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.DeleteManagedPrefixListInput, arg2 ...request.Option) (*ec2.DeleteManagedPrefixListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteManagedPrefixListWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteManagedPrefixListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteManagedPrefixListWithContext indicates an expected call of DeleteManagedPrefixListWithContext +func (mr *MockEC2APIMockRecorder) DeleteManagedPrefixListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixListWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteManagedPrefixListWithContext), varargs...) +} + +// DeleteNatGateway mocks base method +func (m *MockEC2API) DeleteNatGateway(arg0 *ec2.DeleteNatGatewayInput) (*ec2.DeleteNatGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNatGateway", arg0) + ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNatGateway indicates an expected call of DeleteNatGateway +func (mr *MockEC2APIMockRecorder) DeleteNatGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGateway), arg0) +} + +// DeleteNatGatewayRequest mocks base method +func (m *MockEC2API) DeleteNatGatewayRequest(arg0 *ec2.DeleteNatGatewayInput) (*request.Request, *ec2.DeleteNatGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNatGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteNatGatewayOutput) + return ret0, ret1 +} + +// DeleteNatGatewayRequest indicates an expected call of DeleteNatGatewayRequest +func (mr *MockEC2APIMockRecorder) DeleteNatGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGatewayRequest), arg0) +} + +// DeleteNatGatewayWithContext mocks base method +func (m *MockEC2API) DeleteNatGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteNatGatewayInput, arg2 ...request.Option) (*ec2.DeleteNatGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNatGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNatGatewayWithContext indicates an expected call of DeleteNatGatewayWithContext +func (mr *MockEC2APIMockRecorder) DeleteNatGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGatewayWithContext), varargs...) +} + +// DeleteNetworkAcl mocks base method +func (m *MockEC2API) DeleteNetworkAcl(arg0 *ec2.DeleteNetworkAclInput) (*ec2.DeleteNetworkAclOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkAcl", arg0) + ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkAcl indicates an expected call of DeleteNetworkAcl +func (mr *MockEC2APIMockRecorder) DeleteNetworkAcl(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAcl), arg0) +} + +// DeleteNetworkAclEntry mocks base method +func (m *MockEC2API) DeleteNetworkAclEntry(arg0 *ec2.DeleteNetworkAclEntryInput) (*ec2.DeleteNetworkAclEntryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkAclEntry", arg0) + ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkAclEntry indicates an expected call of DeleteNetworkAclEntry +func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntry(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntry), arg0) +} + +// DeleteNetworkAclEntryRequest mocks base method +func (m *MockEC2API) DeleteNetworkAclEntryRequest(arg0 *ec2.DeleteNetworkAclEntryInput) (*request.Request, *ec2.DeleteNetworkAclEntryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkAclEntryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteNetworkAclEntryOutput) + return ret0, ret1 +} + +// DeleteNetworkAclEntryRequest indicates an expected call of DeleteNetworkAclEntryRequest +func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntryRequest), arg0) +} + +// DeleteNetworkAclEntryWithContext mocks base method +func (m *MockEC2API) DeleteNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkAclEntryInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclEntryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNetworkAclEntryWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkAclEntryWithContext indicates an expected call of DeleteNetworkAclEntryWithContext +func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntryWithContext), varargs...) +} + +// DeleteNetworkAclRequest mocks base method +func (m *MockEC2API) DeleteNetworkAclRequest(arg0 *ec2.DeleteNetworkAclInput) (*request.Request, *ec2.DeleteNetworkAclOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkAclRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteNetworkAclOutput) + return ret0, ret1 +} + +// DeleteNetworkAclRequest indicates an expected call of DeleteNetworkAclRequest +func (mr *MockEC2APIMockRecorder) DeleteNetworkAclRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclRequest), arg0) +} + +// DeleteNetworkAclWithContext mocks base method +func (m *MockEC2API) DeleteNetworkAclWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkAclInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNetworkAclWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkAclWithContext indicates an expected call of DeleteNetworkAclWithContext +func (mr *MockEC2APIMockRecorder) DeleteNetworkAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclWithContext), varargs...) +} + +// DeleteNetworkInterface mocks base method +func (m *MockEC2API) DeleteNetworkInterface(arg0 *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkInterface", arg0) + ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkInterface indicates an expected call of DeleteNetworkInterface +func (mr *MockEC2APIMockRecorder) DeleteNetworkInterface(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterface), arg0) +} + +// DeleteNetworkInterfacePermission mocks base method +func (m *MockEC2API) DeleteNetworkInterfacePermission(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*ec2.DeleteNetworkInterfacePermissionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermission", arg0) + ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkInterfacePermission indicates an expected call of DeleteNetworkInterfacePermission +func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermission(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermission), arg0) +} + +// DeleteNetworkInterfacePermissionRequest mocks base method +func (m *MockEC2API) DeleteNetworkInterfacePermissionRequest(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*request.Request, *ec2.DeleteNetworkInterfacePermissionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteNetworkInterfacePermissionOutput) + return ret0, ret1 +} + +// DeleteNetworkInterfacePermissionRequest indicates an expected call of DeleteNetworkInterfacePermissionRequest +func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermissionRequest), arg0) +} + +// DeleteNetworkInterfacePermissionWithContext mocks base method +func (m *MockEC2API) DeleteNetworkInterfacePermissionWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfacePermissionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkInterfacePermissionWithContext indicates an expected call of DeleteNetworkInterfacePermissionWithContext +func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermissionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermissionWithContext), varargs...) +} + +// DeleteNetworkInterfaceRequest mocks base method +func (m *MockEC2API) DeleteNetworkInterfaceRequest(arg0 *ec2.DeleteNetworkInterfaceInput) (*request.Request, *ec2.DeleteNetworkInterfaceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNetworkInterfaceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteNetworkInterfaceOutput) + return ret0, ret1 +} + +// DeleteNetworkInterfaceRequest indicates an expected call of DeleteNetworkInterfaceRequest +func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfaceRequest), arg0) +} + +// DeleteNetworkInterfaceWithContext mocks base method +func (m *MockEC2API) DeleteNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfaceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNetworkInterfaceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNetworkInterfaceWithContext indicates an expected call of DeleteNetworkInterfaceWithContext +func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfaceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfaceWithContext), varargs...) +} + +// DeletePlacementGroup mocks base method +func (m *MockEC2API) DeletePlacementGroup(arg0 *ec2.DeletePlacementGroupInput) (*ec2.DeletePlacementGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePlacementGroup", arg0) + ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePlacementGroup indicates an expected call of DeletePlacementGroup +func (mr *MockEC2APIMockRecorder) DeletePlacementGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroup), arg0) +} + +// DeletePlacementGroupRequest mocks base method +func (m *MockEC2API) DeletePlacementGroupRequest(arg0 *ec2.DeletePlacementGroupInput) (*request.Request, *ec2.DeletePlacementGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePlacementGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeletePlacementGroupOutput) + return ret0, ret1 +} + +// DeletePlacementGroupRequest indicates an expected call of DeletePlacementGroupRequest +func (mr *MockEC2APIMockRecorder) DeletePlacementGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroupRequest), arg0) +} + +// DeletePlacementGroupWithContext mocks base method +func (m *MockEC2API) DeletePlacementGroupWithContext(arg0 context.Context, arg1 *ec2.DeletePlacementGroupInput, arg2 ...request.Option) (*ec2.DeletePlacementGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePlacementGroupWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePlacementGroupWithContext indicates an expected call of DeletePlacementGroupWithContext +func (mr *MockEC2APIMockRecorder) DeletePlacementGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroupWithContext), varargs...) +} + +// DeleteQueuedReservedInstances mocks base method +func (m *MockEC2API) DeleteQueuedReservedInstances(arg0 *ec2.DeleteQueuedReservedInstancesInput) (*ec2.DeleteQueuedReservedInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteQueuedReservedInstances", arg0) + ret0, _ := ret[0].(*ec2.DeleteQueuedReservedInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteQueuedReservedInstances indicates an expected call of DeleteQueuedReservedInstances +func (mr *MockEC2APIMockRecorder) DeleteQueuedReservedInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstances), arg0) +} + +// DeleteQueuedReservedInstancesRequest mocks base method +func (m *MockEC2API) DeleteQueuedReservedInstancesRequest(arg0 *ec2.DeleteQueuedReservedInstancesInput) (*request.Request, *ec2.DeleteQueuedReservedInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteQueuedReservedInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteQueuedReservedInstancesOutput) + return ret0, ret1 +} + +// DeleteQueuedReservedInstancesRequest indicates an expected call of DeleteQueuedReservedInstancesRequest +func (mr *MockEC2APIMockRecorder) DeleteQueuedReservedInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstancesRequest), arg0) +} + +// DeleteQueuedReservedInstancesWithContext mocks base method +func (m *MockEC2API) DeleteQueuedReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.DeleteQueuedReservedInstancesInput, arg2 ...request.Option) (*ec2.DeleteQueuedReservedInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteQueuedReservedInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteQueuedReservedInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteQueuedReservedInstancesWithContext indicates an expected call of DeleteQueuedReservedInstancesWithContext +func (mr *MockEC2APIMockRecorder) DeleteQueuedReservedInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstancesWithContext), varargs...) +} + +// DeleteRoute mocks base method +func (m *MockEC2API) DeleteRoute(arg0 *ec2.DeleteRouteInput) (*ec2.DeleteRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRoute", arg0) + ret0, _ := ret[0].(*ec2.DeleteRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRoute indicates an expected call of DeleteRoute +func (mr *MockEC2APIMockRecorder) DeleteRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteRoute), arg0) +} + +// DeleteRouteRequest mocks base method +func (m *MockEC2API) DeleteRouteRequest(arg0 *ec2.DeleteRouteInput) (*request.Request, *ec2.DeleteRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteRouteOutput) + return ret0, ret1 +} + +// DeleteRouteRequest indicates an expected call of DeleteRouteRequest +func (mr *MockEC2APIMockRecorder) DeleteRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteRequest), arg0) +} + +// DeleteRouteTable mocks base method +func (m *MockEC2API) DeleteRouteTable(arg0 *ec2.DeleteRouteTableInput) (*ec2.DeleteRouteTableOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRouteTable", arg0) + ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRouteTable indicates an expected call of DeleteRouteTable +func (mr *MockEC2APIMockRecorder) DeleteRouteTable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTable), arg0) +} + +// DeleteRouteTableRequest mocks base method +func (m *MockEC2API) DeleteRouteTableRequest(arg0 *ec2.DeleteRouteTableInput) (*request.Request, *ec2.DeleteRouteTableOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRouteTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteRouteTableOutput) + return ret0, ret1 +} + +// DeleteRouteTableRequest indicates an expected call of DeleteRouteTableRequest +func (mr *MockEC2APIMockRecorder) DeleteRouteTableRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTableRequest), arg0) +} + +// DeleteRouteTableWithContext mocks base method +func (m *MockEC2API) DeleteRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteRouteTableInput, arg2 ...request.Option) (*ec2.DeleteRouteTableOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRouteTableWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRouteTableWithContext indicates an expected call of DeleteRouteTableWithContext +func (mr *MockEC2APIMockRecorder) DeleteRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTableWithContext), varargs...) +} + +// DeleteRouteWithContext mocks base method +func (m *MockEC2API) DeleteRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteRouteInput, arg2 ...request.Option) (*ec2.DeleteRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRouteWithContext indicates an expected call of DeleteRouteWithContext +func (mr *MockEC2APIMockRecorder) DeleteRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteWithContext), varargs...) +} + +// DeleteSecurityGroup mocks base method +func (m *MockEC2API) DeleteSecurityGroup(arg0 *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSecurityGroup", arg0) + ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup +func (mr *MockEC2APIMockRecorder) DeleteSecurityGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroup), arg0) +} + +// DeleteSecurityGroupRequest mocks base method +func (m *MockEC2API) DeleteSecurityGroupRequest(arg0 *ec2.DeleteSecurityGroupInput) (*request.Request, *ec2.DeleteSecurityGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSecurityGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteSecurityGroupOutput) + return ret0, ret1 +} + +// DeleteSecurityGroupRequest indicates an expected call of DeleteSecurityGroupRequest +func (mr *MockEC2APIMockRecorder) DeleteSecurityGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroupRequest), arg0) +} + +// DeleteSecurityGroupWithContext mocks base method +func (m *MockEC2API) DeleteSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.DeleteSecurityGroupInput, arg2 ...request.Option) (*ec2.DeleteSecurityGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteSecurityGroupWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSecurityGroupWithContext indicates an expected call of DeleteSecurityGroupWithContext +func (mr *MockEC2APIMockRecorder) DeleteSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroupWithContext), varargs...) +} + +// DeleteSnapshot mocks base method +func (m *MockEC2API) DeleteSnapshot(arg0 *ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSnapshot", arg0) + ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSnapshot indicates an expected call of DeleteSnapshot +func (mr *MockEC2APIMockRecorder) DeleteSnapshot(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshot), arg0) +} + +// DeleteSnapshotRequest mocks base method +func (m *MockEC2API) DeleteSnapshotRequest(arg0 *ec2.DeleteSnapshotInput) (*request.Request, *ec2.DeleteSnapshotOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSnapshotRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteSnapshotOutput) + return ret0, ret1 +} + +// DeleteSnapshotRequest indicates an expected call of DeleteSnapshotRequest +func (mr *MockEC2APIMockRecorder) DeleteSnapshotRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshotRequest), arg0) +} + +// DeleteSnapshotWithContext mocks base method +func (m *MockEC2API) DeleteSnapshotWithContext(arg0 context.Context, arg1 *ec2.DeleteSnapshotInput, arg2 ...request.Option) (*ec2.DeleteSnapshotOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteSnapshotWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSnapshotWithContext indicates an expected call of DeleteSnapshotWithContext +func (mr *MockEC2APIMockRecorder) DeleteSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshotWithContext), varargs...) +} + +// DeleteSpotDatafeedSubscription mocks base method +func (m *MockEC2API) DeleteSpotDatafeedSubscription(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscription", arg0) + ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSpotDatafeedSubscription indicates an expected call of DeleteSpotDatafeedSubscription +func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscription), arg0) +} + +// DeleteSpotDatafeedSubscriptionRequest mocks base method +func (m *MockEC2API) DeleteSpotDatafeedSubscriptionRequest(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteSpotDatafeedSubscriptionOutput) + return ret0, ret1 +} + +// DeleteSpotDatafeedSubscriptionRequest indicates an expected call of DeleteSpotDatafeedSubscriptionRequest +func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionRequest), arg0) +} + +// DeleteSpotDatafeedSubscriptionWithContext mocks base method +func (m *MockEC2API) DeleteSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DeleteSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSpotDatafeedSubscriptionWithContext indicates an expected call of DeleteSpotDatafeedSubscriptionWithContext +func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionWithContext), varargs...) +} + +// DeleteSubnet mocks base method +func (m *MockEC2API) DeleteSubnet(arg0 *ec2.DeleteSubnetInput) (*ec2.DeleteSubnetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSubnet", arg0) + ret0, _ := ret[0].(*ec2.DeleteSubnetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSubnet indicates an expected call of DeleteSubnet +func (mr *MockEC2APIMockRecorder) DeleteSubnet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnet), arg0) +} + +// DeleteSubnetRequest mocks base method +func (m *MockEC2API) DeleteSubnetRequest(arg0 *ec2.DeleteSubnetInput) (*request.Request, *ec2.DeleteSubnetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSubnetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteSubnetOutput) + return ret0, ret1 +} + +// DeleteSubnetRequest indicates an expected call of DeleteSubnetRequest +func (mr *MockEC2APIMockRecorder) DeleteSubnetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetRequest), arg0) +} + +// DeleteSubnetWithContext mocks base method +func (m *MockEC2API) DeleteSubnetWithContext(arg0 context.Context, arg1 *ec2.DeleteSubnetInput, arg2 ...request.Option) (*ec2.DeleteSubnetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteSubnetWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteSubnetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSubnetWithContext indicates an expected call of DeleteSubnetWithContext +func (mr *MockEC2APIMockRecorder) DeleteSubnetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetWithContext), varargs...) +} + +// DeleteTags mocks base method +func (m *MockEC2API) DeleteTags(arg0 *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTags", arg0) + ret0, _ := ret[0].(*ec2.DeleteTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTags indicates an expected call of DeleteTags +func (mr *MockEC2APIMockRecorder) DeleteTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockEC2API)(nil).DeleteTags), arg0) +} + +// DeleteTagsRequest mocks base method +func (m *MockEC2API) DeleteTagsRequest(arg0 *ec2.DeleteTagsInput) (*request.Request, *ec2.DeleteTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTagsOutput) + return ret0, ret1 +} + +// DeleteTagsRequest indicates an expected call of DeleteTagsRequest +func (mr *MockEC2APIMockRecorder) DeleteTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTagsRequest), arg0) +} + +// DeleteTagsWithContext mocks base method +func (m *MockEC2API) DeleteTagsWithContext(arg0 context.Context, arg1 *ec2.DeleteTagsInput, arg2 ...request.Option) (*ec2.DeleteTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTagsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTagsWithContext indicates an expected call of DeleteTagsWithContext +func (mr *MockEC2APIMockRecorder) DeleteTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTagsWithContext), varargs...) +} + +// DeleteTrafficMirrorFilter mocks base method +func (m *MockEC2API) DeleteTrafficMirrorFilter(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*ec2.DeleteTrafficMirrorFilterOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilter", arg0) + ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficMirrorFilter indicates an expected call of DeleteTrafficMirrorFilter +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilter(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilter), arg0) +} + +// DeleteTrafficMirrorFilterRequest mocks base method +func (m *MockEC2API) DeleteTrafficMirrorFilterRequest(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterOutput) + return ret0, ret1 +} + +// DeleteTrafficMirrorFilterRequest indicates an expected call of DeleteTrafficMirrorFilterRequest +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRequest), arg0) +} + +// DeleteTrafficMirrorFilterRule mocks base method +func (m *MockEC2API) DeleteTrafficMirrorFilterRule(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRule", arg0) + ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficMirrorFilterRule indicates an expected call of DeleteTrafficMirrorFilterRule +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRule), arg0) +} + +// DeleteTrafficMirrorFilterRuleRequest mocks base method +func (m *MockEC2API) DeleteTrafficMirrorFilterRuleRequest(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterRuleOutput) + return ret0, ret1 +} + +// DeleteTrafficMirrorFilterRuleRequest indicates an expected call of DeleteTrafficMirrorFilterRuleRequest +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleRequest), arg0) +} + +// DeleteTrafficMirrorFilterRuleWithContext mocks base method +func (m *MockEC2API) DeleteTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficMirrorFilterRuleWithContext indicates an expected call of DeleteTrafficMirrorFilterRuleWithContext +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleWithContext), varargs...) +} + +// DeleteTrafficMirrorFilterWithContext mocks base method +func (m *MockEC2API) DeleteTrafficMirrorFilterWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficMirrorFilterWithContext indicates an expected call of DeleteTrafficMirrorFilterWithContext +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterWithContext), varargs...) +} + +// DeleteTrafficMirrorSession mocks base method +func (m *MockEC2API) DeleteTrafficMirrorSession(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*ec2.DeleteTrafficMirrorSessionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficMirrorSession", arg0) + ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficMirrorSession indicates an expected call of DeleteTrafficMirrorSession +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSession(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSession), arg0) +} + +// DeleteTrafficMirrorSessionRequest mocks base method +func (m *MockEC2API) DeleteTrafficMirrorSessionRequest(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*request.Request, *ec2.DeleteTrafficMirrorSessionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorSessionOutput) + return ret0, ret1 +} + +// DeleteTrafficMirrorSessionRequest indicates an expected call of DeleteTrafficMirrorSessionRequest +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSessionRequest), arg0) +} + +// DeleteTrafficMirrorSessionWithContext mocks base method +func (m *MockEC2API) DeleteTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorSessionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficMirrorSessionWithContext indicates an expected call of DeleteTrafficMirrorSessionWithContext +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSessionWithContext), varargs...) +} + +// DeleteTrafficMirrorTarget mocks base method +func (m *MockEC2API) DeleteTrafficMirrorTarget(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*ec2.DeleteTrafficMirrorTargetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficMirrorTarget", arg0) + ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficMirrorTarget indicates an expected call of DeleteTrafficMirrorTarget +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTarget(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTarget), arg0) +} + +// DeleteTrafficMirrorTargetRequest mocks base method +func (m *MockEC2API) DeleteTrafficMirrorTargetRequest(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*request.Request, *ec2.DeleteTrafficMirrorTargetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorTargetOutput) + return ret0, ret1 +} + +// DeleteTrafficMirrorTargetRequest indicates an expected call of DeleteTrafficMirrorTargetRequest +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTargetRequest), arg0) +} + +// DeleteTrafficMirrorTargetWithContext mocks base method +func (m *MockEC2API) DeleteTrafficMirrorTargetWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorTargetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTrafficMirrorTargetWithContext indicates an expected call of DeleteTrafficMirrorTargetWithContext +func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTargetWithContext), varargs...) +} + +// DeleteTransitGateway mocks base method +func (m *MockEC2API) DeleteTransitGateway(arg0 *ec2.DeleteTransitGatewayInput) (*ec2.DeleteTransitGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGateway", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGateway indicates an expected call of DeleteTransitGateway +func (mr *MockEC2APIMockRecorder) DeleteTransitGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGateway), arg0) +} + +// DeleteTransitGatewayMulticastDomain mocks base method +func (m *MockEC2API) DeleteTransitGatewayMulticastDomain(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomain", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayMulticastDomain indicates an expected call of DeleteTransitGatewayMulticastDomain +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomain), arg0) +} + +// DeleteTransitGatewayMulticastDomainRequest mocks base method +func (m *MockEC2API) DeleteTransitGatewayMulticastDomainRequest(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DeleteTransitGatewayMulticastDomainOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomainRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayMulticastDomainOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayMulticastDomainRequest indicates an expected call of DeleteTransitGatewayMulticastDomainRequest +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomainRequest), arg0) +} + +// DeleteTransitGatewayMulticastDomainWithContext mocks base method +func (m *MockEC2API) DeleteTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomainWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayMulticastDomainWithContext indicates an expected call of DeleteTransitGatewayMulticastDomainWithContext +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomainWithContext), varargs...) +} + +// DeleteTransitGatewayPeeringAttachment mocks base method +func (m *MockEC2API) DeleteTransitGatewayPeeringAttachment(arg0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachment", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayPeeringAttachment indicates an expected call of DeleteTransitGatewayPeeringAttachment +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachment), arg0) +} + +// DeleteTransitGatewayPeeringAttachmentRequest mocks base method +func (m *MockEC2API) DeleteTransitGatewayPeeringAttachmentRequest(arg0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayPeeringAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayPeeringAttachmentRequest indicates an expected call of DeleteTransitGatewayPeeringAttachmentRequest +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachmentRequest), arg0) +} + +// DeleteTransitGatewayPeeringAttachmentWithContext mocks base method +func (m *MockEC2API) DeleteTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayPeeringAttachmentWithContext indicates an expected call of DeleteTransitGatewayPeeringAttachmentWithContext +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachmentWithContext), varargs...) +} + +// DeleteTransitGatewayPrefixListReference mocks base method +func (m *MockEC2API) DeleteTransitGatewayPrefixListReference(arg0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReference", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayPrefixListReference indicates an expected call of DeleteTransitGatewayPrefixListReference +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPrefixListReference), arg0) +} + +// DeleteTransitGatewayPrefixListReferenceRequest mocks base method +func (m *MockEC2API) DeleteTransitGatewayPrefixListReferenceRequest(arg0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.DeleteTransitGatewayPrefixListReferenceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReferenceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayPrefixListReferenceRequest indicates an expected call of DeleteTransitGatewayPrefixListReferenceRequest +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPrefixListReferenceRequest), arg0) +} + +// DeleteTransitGatewayPrefixListReferenceWithContext mocks base method +func (m *MockEC2API) DeleteTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReferenceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayPrefixListReferenceWithContext indicates an expected call of DeleteTransitGatewayPrefixListReferenceWithContext +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayPrefixListReferenceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPrefixListReferenceWithContext), varargs...) +} + +// DeleteTransitGatewayRequest mocks base method +func (m *MockEC2API) DeleteTransitGatewayRequest(arg0 *ec2.DeleteTransitGatewayInput) (*request.Request, *ec2.DeleteTransitGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayRequest indicates an expected call of DeleteTransitGatewayRequest +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRequest), arg0) +} + +// DeleteTransitGatewayRoute mocks base method +func (m *MockEC2API) DeleteTransitGatewayRoute(arg0 *ec2.DeleteTransitGatewayRouteInput) (*ec2.DeleteTransitGatewayRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayRoute", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayRoute indicates an expected call of DeleteTransitGatewayRoute +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRoute), arg0) +} + +// DeleteTransitGatewayRouteRequest mocks base method +func (m *MockEC2API) DeleteTransitGatewayRouteRequest(arg0 *ec2.DeleteTransitGatewayRouteInput) (*request.Request, *ec2.DeleteTransitGatewayRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayRouteRequest indicates an expected call of DeleteTransitGatewayRouteRequest +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteRequest), arg0) +} + +// DeleteTransitGatewayRouteTable mocks base method +func (m *MockEC2API) DeleteTransitGatewayRouteTable(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*ec2.DeleteTransitGatewayRouteTableOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTable", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayRouteTable indicates an expected call of DeleteTransitGatewayRouteTable +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTable), arg0) +} + +// DeleteTransitGatewayRouteTableRequest mocks base method +func (m *MockEC2API) DeleteTransitGatewayRouteTableRequest(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteTableOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayRouteTableRequest indicates an expected call of DeleteTransitGatewayRouteTableRequest +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableRequest), arg0) +} + +// DeleteTransitGatewayRouteTableWithContext mocks base method +func (m *MockEC2API) DeleteTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayRouteTableWithContext indicates an expected call of DeleteTransitGatewayRouteTableWithContext +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableWithContext), varargs...) +} + +// DeleteTransitGatewayRouteWithContext mocks base method +func (m *MockEC2API) DeleteTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayRouteWithContext indicates an expected call of DeleteTransitGatewayRouteWithContext +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteWithContext), varargs...) +} + +// DeleteTransitGatewayVpcAttachment mocks base method +func (m *MockEC2API) DeleteTransitGatewayVpcAttachment(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachment", arg0) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayVpcAttachment indicates an expected call of DeleteTransitGatewayVpcAttachment +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachment), arg0) +} + +// DeleteTransitGatewayVpcAttachmentRequest mocks base method +func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentRequest(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayVpcAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) + return ret0, ret1 +} + +// DeleteTransitGatewayVpcAttachmentRequest indicates an expected call of DeleteTransitGatewayVpcAttachmentRequest +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentRequest), arg0) +} + +// DeleteTransitGatewayVpcAttachmentWithContext mocks base method +func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayVpcAttachmentWithContext indicates an expected call of DeleteTransitGatewayVpcAttachmentWithContext +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentWithContext), varargs...) +} + +// DeleteTransitGatewayWithContext mocks base method +func (m *MockEC2API) DeleteTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteTransitGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTransitGatewayWithContext indicates an expected call of DeleteTransitGatewayWithContext +func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayWithContext), varargs...) +} + +// DeleteVolume mocks base method +func (m *MockEC2API) DeleteVolume(arg0 *ec2.DeleteVolumeInput) (*ec2.DeleteVolumeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVolume", arg0) + ret0, _ := ret[0].(*ec2.DeleteVolumeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVolume indicates an expected call of DeleteVolume +func (mr *MockEC2APIMockRecorder) DeleteVolume(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockEC2API)(nil).DeleteVolume), arg0) +} + +// DeleteVolumeRequest mocks base method +func (m *MockEC2API) DeleteVolumeRequest(arg0 *ec2.DeleteVolumeInput) (*request.Request, *ec2.DeleteVolumeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVolumeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVolumeOutput) + return ret0, ret1 +} + +// DeleteVolumeRequest indicates an expected call of DeleteVolumeRequest +func (mr *MockEC2APIMockRecorder) DeleteVolumeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVolumeRequest), arg0) +} + +// DeleteVolumeWithContext mocks base method +func (m *MockEC2API) DeleteVolumeWithContext(arg0 context.Context, arg1 *ec2.DeleteVolumeInput, arg2 ...request.Option) (*ec2.DeleteVolumeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVolumeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVolumeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVolumeWithContext indicates an expected call of DeleteVolumeWithContext +func (mr *MockEC2APIMockRecorder) DeleteVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVolumeWithContext), varargs...) +} + +// DeleteVpc mocks base method +func (m *MockEC2API) DeleteVpc(arg0 *ec2.DeleteVpcInput) (*ec2.DeleteVpcOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpc", arg0) + ret0, _ := ret[0].(*ec2.DeleteVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpc indicates an expected call of DeleteVpc +func (mr *MockEC2APIMockRecorder) DeleteVpc(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockEC2API)(nil).DeleteVpc), arg0) +} + +// DeleteVpcEndpointConnectionNotifications mocks base method +func (m *MockEC2API) DeleteVpcEndpointConnectionNotifications(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotifications", arg0) + ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcEndpointConnectionNotifications indicates an expected call of DeleteVpcEndpointConnectionNotifications +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotifications), arg0) +} + +// DeleteVpcEndpointConnectionNotificationsRequest mocks base method +func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DeleteVpcEndpointConnectionNotificationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) + return ret0, ret1 +} + +// DeleteVpcEndpointConnectionNotificationsRequest indicates an expected call of DeleteVpcEndpointConnectionNotificationsRequest +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsRequest), arg0) +} + +// DeleteVpcEndpointConnectionNotificationsWithContext mocks base method +func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcEndpointConnectionNotificationsWithContext indicates an expected call of DeleteVpcEndpointConnectionNotificationsWithContext +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsWithContext), varargs...) +} + +// DeleteVpcEndpointServiceConfigurations mocks base method +func (m *MockEC2API) DeleteVpcEndpointServiceConfigurations(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurations", arg0) + ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcEndpointServiceConfigurations indicates an expected call of DeleteVpcEndpointServiceConfigurations +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurations), arg0) +} + +// DeleteVpcEndpointServiceConfigurationsRequest mocks base method +func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DeleteVpcEndpointServiceConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) + return ret0, ret1 +} + +// DeleteVpcEndpointServiceConfigurationsRequest indicates an expected call of DeleteVpcEndpointServiceConfigurationsRequest +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsRequest), arg0) +} + +// DeleteVpcEndpointServiceConfigurationsWithContext mocks base method +func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcEndpointServiceConfigurationsWithContext indicates an expected call of DeleteVpcEndpointServiceConfigurationsWithContext +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsWithContext), varargs...) +} + +// DeleteVpcEndpoints mocks base method +func (m *MockEC2API) DeleteVpcEndpoints(arg0 *ec2.DeleteVpcEndpointsInput) (*ec2.DeleteVpcEndpointsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcEndpoints", arg0) + ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcEndpoints indicates an expected call of DeleteVpcEndpoints +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpoints(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpoints), arg0) +} + +// DeleteVpcEndpointsRequest mocks base method +func (m *MockEC2API) DeleteVpcEndpointsRequest(arg0 *ec2.DeleteVpcEndpointsInput) (*request.Request, *ec2.DeleteVpcEndpointsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcEndpointsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVpcEndpointsOutput) + return ret0, ret1 +} + +// DeleteVpcEndpointsRequest indicates an expected call of DeleteVpcEndpointsRequest +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointsRequest), arg0) +} + +// DeleteVpcEndpointsWithContext mocks base method +func (m *MockEC2API) DeleteVpcEndpointsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpcEndpointsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcEndpointsWithContext indicates an expected call of DeleteVpcEndpointsWithContext +func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointsWithContext), varargs...) +} + +// DeleteVpcPeeringConnection mocks base method +func (m *MockEC2API) DeleteVpcPeeringConnection(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*ec2.DeleteVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcPeeringConnection", arg0) + ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcPeeringConnection indicates an expected call of DeleteVpcPeeringConnection +func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnection), arg0) +} + +// DeleteVpcPeeringConnectionRequest mocks base method +func (m *MockEC2API) DeleteVpcPeeringConnectionRequest(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*request.Request, *ec2.DeleteVpcPeeringConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVpcPeeringConnectionOutput) + return ret0, ret1 +} + +// DeleteVpcPeeringConnectionRequest indicates an expected call of DeleteVpcPeeringConnectionRequest +func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnectionRequest), arg0) +} + +// DeleteVpcPeeringConnectionWithContext mocks base method +func (m *MockEC2API) DeleteVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcPeeringConnectionWithContext indicates an expected call of DeleteVpcPeeringConnectionWithContext +func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnectionWithContext), varargs...) +} + +// DeleteVpcRequest mocks base method +func (m *MockEC2API) DeleteVpcRequest(arg0 *ec2.DeleteVpcInput) (*request.Request, *ec2.DeleteVpcOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpcRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVpcOutput) + return ret0, ret1 +} + +// DeleteVpcRequest indicates an expected call of DeleteVpcRequest +func (mr *MockEC2APIMockRecorder) DeleteVpcRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcRequest), arg0) +} + +// DeleteVpcWithContext mocks base method +func (m *MockEC2API) DeleteVpcWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcInput, arg2 ...request.Option) (*ec2.DeleteVpcOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpcWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpcWithContext indicates an expected call of DeleteVpcWithContext +func (mr *MockEC2APIMockRecorder) DeleteVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcWithContext), varargs...) +} + +// DeleteVpnConnection mocks base method +func (m *MockEC2API) DeleteVpnConnection(arg0 *ec2.DeleteVpnConnectionInput) (*ec2.DeleteVpnConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpnConnection", arg0) + ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpnConnection indicates an expected call of DeleteVpnConnection +func (mr *MockEC2APIMockRecorder) DeleteVpnConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnection), arg0) +} + +// DeleteVpnConnectionRequest mocks base method +func (m *MockEC2API) DeleteVpnConnectionRequest(arg0 *ec2.DeleteVpnConnectionInput) (*request.Request, *ec2.DeleteVpnConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpnConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVpnConnectionOutput) + return ret0, ret1 +} + +// DeleteVpnConnectionRequest indicates an expected call of DeleteVpnConnectionRequest +func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRequest), arg0) +} + +// DeleteVpnConnectionRoute mocks base method +func (m *MockEC2API) DeleteVpnConnectionRoute(arg0 *ec2.DeleteVpnConnectionRouteInput) (*ec2.DeleteVpnConnectionRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpnConnectionRoute", arg0) + ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpnConnectionRoute indicates an expected call of DeleteVpnConnectionRoute +func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRoute), arg0) +} + +// DeleteVpnConnectionRouteRequest mocks base method +func (m *MockEC2API) DeleteVpnConnectionRouteRequest(arg0 *ec2.DeleteVpnConnectionRouteInput) (*request.Request, *ec2.DeleteVpnConnectionRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVpnConnectionRouteOutput) + return ret0, ret1 +} + +// DeleteVpnConnectionRouteRequest indicates an expected call of DeleteVpnConnectionRouteRequest +func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRouteRequest), arg0) +} + +// DeleteVpnConnectionRouteWithContext mocks base method +func (m *MockEC2API) DeleteVpnConnectionRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpnConnectionRouteWithContext indicates an expected call of DeleteVpnConnectionRouteWithContext +func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRouteWithContext), varargs...) +} + +// DeleteVpnConnectionWithContext mocks base method +func (m *MockEC2API) DeleteVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpnConnectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpnConnectionWithContext indicates an expected call of DeleteVpnConnectionWithContext +func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionWithContext), varargs...) +} + +// DeleteVpnGateway mocks base method +func (m *MockEC2API) DeleteVpnGateway(arg0 *ec2.DeleteVpnGatewayInput) (*ec2.DeleteVpnGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpnGateway", arg0) + ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpnGateway indicates an expected call of DeleteVpnGateway +func (mr *MockEC2APIMockRecorder) DeleteVpnGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGateway), arg0) +} + +// DeleteVpnGatewayRequest mocks base method +func (m *MockEC2API) DeleteVpnGatewayRequest(arg0 *ec2.DeleteVpnGatewayInput) (*request.Request, *ec2.DeleteVpnGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVpnGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeleteVpnGatewayOutput) + return ret0, ret1 +} + +// DeleteVpnGatewayRequest indicates an expected call of DeleteVpnGatewayRequest +func (mr *MockEC2APIMockRecorder) DeleteVpnGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGatewayRequest), arg0) +} + +// DeleteVpnGatewayWithContext mocks base method +func (m *MockEC2API) DeleteVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnGatewayInput, arg2 ...request.Option) (*ec2.DeleteVpnGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVpnGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVpnGatewayWithContext indicates an expected call of DeleteVpnGatewayWithContext +func (mr *MockEC2APIMockRecorder) DeleteVpnGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGatewayWithContext), varargs...) +} + +// DeprovisionByoipCidr mocks base method +func (m *MockEC2API) DeprovisionByoipCidr(arg0 *ec2.DeprovisionByoipCidrInput) (*ec2.DeprovisionByoipCidrOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeprovisionByoipCidr", arg0) + ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeprovisionByoipCidr indicates an expected call of DeprovisionByoipCidr +func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidr(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidr), arg0) +} + +// DeprovisionByoipCidrRequest mocks base method +func (m *MockEC2API) DeprovisionByoipCidrRequest(arg0 *ec2.DeprovisionByoipCidrInput) (*request.Request, *ec2.DeprovisionByoipCidrOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeprovisionByoipCidrRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeprovisionByoipCidrOutput) + return ret0, ret1 +} + +// DeprovisionByoipCidrRequest indicates an expected call of DeprovisionByoipCidrRequest +func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidrRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidrRequest), arg0) +} + +// DeprovisionByoipCidrWithContext mocks base method +func (m *MockEC2API) DeprovisionByoipCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionByoipCidrInput, arg2 ...request.Option) (*ec2.DeprovisionByoipCidrOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeprovisionByoipCidrWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeprovisionByoipCidrWithContext indicates an expected call of DeprovisionByoipCidrWithContext +func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidrWithContext), varargs...) +} + +// DeregisterImage mocks base method +func (m *MockEC2API) DeregisterImage(arg0 *ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterImage", arg0) + ret0, _ := ret[0].(*ec2.DeregisterImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterImage indicates an expected call of DeregisterImage +func (mr *MockEC2APIMockRecorder) DeregisterImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImage", reflect.TypeOf((*MockEC2API)(nil).DeregisterImage), arg0) +} + +// DeregisterImageRequest mocks base method +func (m *MockEC2API) DeregisterImageRequest(arg0 *ec2.DeregisterImageInput) (*request.Request, *ec2.DeregisterImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeregisterImageOutput) + return ret0, ret1 +} + +// DeregisterImageRequest indicates an expected call of DeregisterImageRequest +func (mr *MockEC2APIMockRecorder) DeregisterImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterImageRequest), arg0) +} + +// DeregisterImageWithContext mocks base method +func (m *MockEC2API) DeregisterImageWithContext(arg0 context.Context, arg1 *ec2.DeregisterImageInput, arg2 ...request.Option) (*ec2.DeregisterImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeregisterImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeregisterImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterImageWithContext indicates an expected call of DeregisterImageWithContext +func (mr *MockEC2APIMockRecorder) DeregisterImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImageWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterImageWithContext), varargs...) +} + +// DeregisterInstanceEventNotificationAttributes mocks base method +func (m *MockEC2API) DeregisterInstanceEventNotificationAttributes(arg0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributes", arg0) + ret0, _ := ret[0].(*ec2.DeregisterInstanceEventNotificationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterInstanceEventNotificationAttributes indicates an expected call of DeregisterInstanceEventNotificationAttributes +func (mr *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributes), arg0) +} + +// DeregisterInstanceEventNotificationAttributesRequest mocks base method +func (m *MockEC2API) DeregisterInstanceEventNotificationAttributesRequest(arg0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DeregisterInstanceEventNotificationAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeregisterInstanceEventNotificationAttributesOutput) + return ret0, ret1 +} + +// DeregisterInstanceEventNotificationAttributesRequest indicates an expected call of DeregisterInstanceEventNotificationAttributesRequest +func (mr *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributesRequest), arg0) +} + +// DeregisterInstanceEventNotificationAttributesWithContext mocks base method +func (m *MockEC2API) DeregisterInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.DeregisterInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeregisterInstanceEventNotificationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterInstanceEventNotificationAttributesWithContext indicates an expected call of DeregisterInstanceEventNotificationAttributesWithContext +func (mr *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributesWithContext), varargs...) +} + +// DeregisterTransitGatewayMulticastGroupMembers mocks base method +func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembers(arg0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembers", arg0) + ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterTransitGatewayMulticastGroupMembers indicates an expected call of DeregisterTransitGatewayMulticastGroupMembers +func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembers), arg0) +} + +// DeregisterTransitGatewayMulticastGroupMembersRequest mocks base method +func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) + return ret0, ret1 +} + +// DeregisterTransitGatewayMulticastGroupMembersRequest indicates an expected call of DeregisterTransitGatewayMulticastGroupMembersRequest +func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembersRequest), arg0) +} + +// DeregisterTransitGatewayMulticastGroupMembersWithContext mocks base method +func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembersWithContext(arg0 context.Context, arg1 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, arg2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembersWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterTransitGatewayMulticastGroupMembersWithContext indicates an expected call of DeregisterTransitGatewayMulticastGroupMembersWithContext +func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembersWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembersWithContext), varargs...) +} + +// DeregisterTransitGatewayMulticastGroupSources mocks base method +func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSources(arg0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSources", arg0) + ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterTransitGatewayMulticastGroupSources indicates an expected call of DeregisterTransitGatewayMulticastGroupSources +func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSources), arg0) +} + +// DeregisterTransitGatewayMulticastGroupSourcesRequest mocks base method +func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSourcesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) + return ret0, ret1 +} + +// DeregisterTransitGatewayMulticastGroupSourcesRequest indicates an expected call of DeregisterTransitGatewayMulticastGroupSourcesRequest +func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSourcesRequest), arg0) +} + +// DeregisterTransitGatewayMulticastGroupSourcesWithContext mocks base method +func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSourcesWithContext(arg0 context.Context, arg1 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, arg2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSourcesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeregisterTransitGatewayMulticastGroupSourcesWithContext indicates an expected call of DeregisterTransitGatewayMulticastGroupSourcesWithContext +func (mr *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSourcesWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSourcesWithContext), varargs...) +} + +// DescribeAccountAttributes mocks base method +func (m *MockEC2API) DescribeAccountAttributes(arg0 *ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountAttributes", arg0) + ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAccountAttributes indicates an expected call of DescribeAccountAttributes +func (mr *MockEC2APIMockRecorder) DescribeAccountAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributes), arg0) +} + +// DescribeAccountAttributesRequest mocks base method +func (m *MockEC2API) DescribeAccountAttributesRequest(arg0 *ec2.DescribeAccountAttributesInput) (*request.Request, *ec2.DescribeAccountAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeAccountAttributesOutput) + return ret0, ret1 +} + +// DescribeAccountAttributesRequest indicates an expected call of DescribeAccountAttributesRequest +func (mr *MockEC2APIMockRecorder) DescribeAccountAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributesRequest), arg0) +} + +// DescribeAccountAttributesWithContext mocks base method +func (m *MockEC2API) DescribeAccountAttributesWithContext(arg0 context.Context, arg1 *ec2.DescribeAccountAttributesInput, arg2 ...request.Option) (*ec2.DescribeAccountAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAccountAttributesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAccountAttributesWithContext indicates an expected call of DescribeAccountAttributesWithContext +func (mr *MockEC2APIMockRecorder) DescribeAccountAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributesWithContext), varargs...) +} + +// DescribeAddresses mocks base method +func (m *MockEC2API) DescribeAddresses(arg0 *ec2.DescribeAddressesInput) (*ec2.DescribeAddressesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAddresses", arg0) + ret0, _ := ret[0].(*ec2.DescribeAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAddresses indicates an expected call of DescribeAddresses +func (mr *MockEC2APIMockRecorder) DescribeAddresses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeAddresses), arg0) +} + +// DescribeAddressesRequest mocks base method +func (m *MockEC2API) DescribeAddressesRequest(arg0 *ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAddressesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeAddressesOutput) + return ret0, ret1 +} + +// DescribeAddressesRequest indicates an expected call of DescribeAddressesRequest +func (mr *MockEC2APIMockRecorder) DescribeAddressesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesRequest), arg0) +} + +// DescribeAddressesWithContext mocks base method +func (m *MockEC2API) DescribeAddressesWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressesInput, arg2 ...request.Option) (*ec2.DescribeAddressesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAddressesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAddressesWithContext indicates an expected call of DescribeAddressesWithContext +func (mr *MockEC2APIMockRecorder) DescribeAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesWithContext), varargs...) +} + +// DescribeAggregateIdFormat mocks base method +func (m *MockEC2API) DescribeAggregateIdFormat(arg0 *ec2.DescribeAggregateIdFormatInput) (*ec2.DescribeAggregateIdFormatOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAggregateIdFormat", arg0) + ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAggregateIdFormat indicates an expected call of DescribeAggregateIdFormat +func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormat), arg0) +} + +// DescribeAggregateIdFormatRequest mocks base method +func (m *MockEC2API) DescribeAggregateIdFormatRequest(arg0 *ec2.DescribeAggregateIdFormatInput) (*request.Request, *ec2.DescribeAggregateIdFormatOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAggregateIdFormatRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeAggregateIdFormatOutput) + return ret0, ret1 +} + +// DescribeAggregateIdFormatRequest indicates an expected call of DescribeAggregateIdFormatRequest +func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormatRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormatRequest), arg0) +} + +// DescribeAggregateIdFormatWithContext mocks base method +func (m *MockEC2API) DescribeAggregateIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeAggregateIdFormatInput, arg2 ...request.Option) (*ec2.DescribeAggregateIdFormatOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAggregateIdFormatWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAggregateIdFormatWithContext indicates an expected call of DescribeAggregateIdFormatWithContext +func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormatWithContext), varargs...) +} + +// DescribeAvailabilityZones mocks base method +func (m *MockEC2API) DescribeAvailabilityZones(arg0 *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAvailabilityZones", arg0) + ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAvailabilityZones indicates an expected call of DescribeAvailabilityZones +func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZones(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZones", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZones), arg0) +} + +// DescribeAvailabilityZonesRequest mocks base method +func (m *MockEC2API) DescribeAvailabilityZonesRequest(arg0 *ec2.DescribeAvailabilityZonesInput) (*request.Request, *ec2.DescribeAvailabilityZonesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAvailabilityZonesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeAvailabilityZonesOutput) + return ret0, ret1 +} + +// DescribeAvailabilityZonesRequest indicates an expected call of DescribeAvailabilityZonesRequest +func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZonesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZonesRequest), arg0) +} + +// DescribeAvailabilityZonesWithContext mocks base method +func (m *MockEC2API) DescribeAvailabilityZonesWithContext(arg0 context.Context, arg1 *ec2.DescribeAvailabilityZonesInput, arg2 ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAvailabilityZonesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAvailabilityZonesWithContext indicates an expected call of DescribeAvailabilityZonesWithContext +func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZonesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZonesWithContext), varargs...) +} + +// DescribeBundleTasks mocks base method +func (m *MockEC2API) DescribeBundleTasks(arg0 *ec2.DescribeBundleTasksInput) (*ec2.DescribeBundleTasksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeBundleTasks", arg0) + ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeBundleTasks indicates an expected call of DescribeBundleTasks +func (mr *MockEC2APIMockRecorder) DescribeBundleTasks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasks), arg0) +} + +// DescribeBundleTasksRequest mocks base method +func (m *MockEC2API) DescribeBundleTasksRequest(arg0 *ec2.DescribeBundleTasksInput) (*request.Request, *ec2.DescribeBundleTasksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeBundleTasksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeBundleTasksOutput) + return ret0, ret1 +} + +// DescribeBundleTasksRequest indicates an expected call of DescribeBundleTasksRequest +func (mr *MockEC2APIMockRecorder) DescribeBundleTasksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasksRequest), arg0) +} + +// DescribeBundleTasksWithContext mocks base method +func (m *MockEC2API) DescribeBundleTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeBundleTasksInput, arg2 ...request.Option) (*ec2.DescribeBundleTasksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeBundleTasksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeBundleTasksWithContext indicates an expected call of DescribeBundleTasksWithContext +func (mr *MockEC2APIMockRecorder) DescribeBundleTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasksWithContext), varargs...) +} + +// DescribeByoipCidrs mocks base method +func (m *MockEC2API) DescribeByoipCidrs(arg0 *ec2.DescribeByoipCidrsInput) (*ec2.DescribeByoipCidrsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeByoipCidrs", arg0) + ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeByoipCidrs indicates an expected call of DescribeByoipCidrs +func (mr *MockEC2APIMockRecorder) DescribeByoipCidrs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrs", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrs), arg0) +} + +// DescribeByoipCidrsPages mocks base method +func (m *MockEC2API) DescribeByoipCidrsPages(arg0 *ec2.DescribeByoipCidrsInput, arg1 func(*ec2.DescribeByoipCidrsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeByoipCidrsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeByoipCidrsPages indicates an expected call of DescribeByoipCidrsPages +func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsPages), arg0, arg1) +} + +// DescribeByoipCidrsPagesWithContext mocks base method +func (m *MockEC2API) DescribeByoipCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 func(*ec2.DescribeByoipCidrsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeByoipCidrsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeByoipCidrsPagesWithContext indicates an expected call of DescribeByoipCidrsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsPagesWithContext), varargs...) +} + +// DescribeByoipCidrsRequest mocks base method +func (m *MockEC2API) DescribeByoipCidrsRequest(arg0 *ec2.DescribeByoipCidrsInput) (*request.Request, *ec2.DescribeByoipCidrsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeByoipCidrsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeByoipCidrsOutput) + return ret0, ret1 +} + +// DescribeByoipCidrsRequest indicates an expected call of DescribeByoipCidrsRequest +func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsRequest), arg0) +} + +// DescribeByoipCidrsWithContext mocks base method +func (m *MockEC2API) DescribeByoipCidrsWithContext(arg0 context.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 ...request.Option) (*ec2.DescribeByoipCidrsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeByoipCidrsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeByoipCidrsWithContext indicates an expected call of DescribeByoipCidrsWithContext +func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsWithContext), varargs...) +} + +// DescribeCapacityReservations mocks base method +func (m *MockEC2API) DescribeCapacityReservations(arg0 *ec2.DescribeCapacityReservationsInput) (*ec2.DescribeCapacityReservationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCapacityReservations", arg0) + ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCapacityReservations indicates an expected call of DescribeCapacityReservations +func (mr *MockEC2APIMockRecorder) DescribeCapacityReservations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservations), arg0) +} + +// DescribeCapacityReservationsPages mocks base method +func (m *MockEC2API) DescribeCapacityReservationsPages(arg0 *ec2.DescribeCapacityReservationsInput, arg1 func(*ec2.DescribeCapacityReservationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCapacityReservationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCapacityReservationsPages indicates an expected call of DescribeCapacityReservationsPages +func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsPages), arg0, arg1) +} + +// DescribeCapacityReservationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeCapacityReservationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 func(*ec2.DescribeCapacityReservationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCapacityReservationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCapacityReservationsPagesWithContext indicates an expected call of DescribeCapacityReservationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsPagesWithContext), varargs...) +} + +// DescribeCapacityReservationsRequest mocks base method +func (m *MockEC2API) DescribeCapacityReservationsRequest(arg0 *ec2.DescribeCapacityReservationsInput) (*request.Request, *ec2.DescribeCapacityReservationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCapacityReservationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeCapacityReservationsOutput) + return ret0, ret1 +} + +// DescribeCapacityReservationsRequest indicates an expected call of DescribeCapacityReservationsRequest +func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsRequest), arg0) +} + +// DescribeCapacityReservationsWithContext mocks base method +func (m *MockEC2API) DescribeCapacityReservationsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 ...request.Option) (*ec2.DescribeCapacityReservationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCapacityReservationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCapacityReservationsWithContext indicates an expected call of DescribeCapacityReservationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsWithContext), varargs...) +} + +// DescribeCarrierGateways mocks base method +func (m *MockEC2API) DescribeCarrierGateways(arg0 *ec2.DescribeCarrierGatewaysInput) (*ec2.DescribeCarrierGatewaysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCarrierGateways", arg0) + ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCarrierGateways indicates an expected call of DescribeCarrierGateways +func (mr *MockEC2APIMockRecorder) DescribeCarrierGateways(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGateways), arg0) +} + +// DescribeCarrierGatewaysPages mocks base method +func (m *MockEC2API) DescribeCarrierGatewaysPages(arg0 *ec2.DescribeCarrierGatewaysInput, arg1 func(*ec2.DescribeCarrierGatewaysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCarrierGatewaysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCarrierGatewaysPages indicates an expected call of DescribeCarrierGatewaysPages +func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysPages), arg0, arg1) +} + +// DescribeCarrierGatewaysPagesWithContext mocks base method +func (m *MockEC2API) DescribeCarrierGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 func(*ec2.DescribeCarrierGatewaysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCarrierGatewaysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCarrierGatewaysPagesWithContext indicates an expected call of DescribeCarrierGatewaysPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysPagesWithContext), varargs...) +} + +// DescribeCarrierGatewaysRequest mocks base method +func (m *MockEC2API) DescribeCarrierGatewaysRequest(arg0 *ec2.DescribeCarrierGatewaysInput) (*request.Request, *ec2.DescribeCarrierGatewaysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCarrierGatewaysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeCarrierGatewaysOutput) + return ret0, ret1 +} + +// DescribeCarrierGatewaysRequest indicates an expected call of DescribeCarrierGatewaysRequest +func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysRequest), arg0) +} + +// DescribeCarrierGatewaysWithContext mocks base method +func (m *MockEC2API) DescribeCarrierGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCarrierGatewaysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCarrierGatewaysWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCarrierGatewaysWithContext indicates an expected call of DescribeCarrierGatewaysWithContext +func (mr *MockEC2APIMockRecorder) DescribeCarrierGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCarrierGatewaysWithContext), varargs...) +} + +// DescribeClassicLinkInstances mocks base method +func (m *MockEC2API) DescribeClassicLinkInstances(arg0 *ec2.DescribeClassicLinkInstancesInput) (*ec2.DescribeClassicLinkInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClassicLinkInstances", arg0) + ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClassicLinkInstances indicates an expected call of DescribeClassicLinkInstances +func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstances), arg0) +} + +// DescribeClassicLinkInstancesPages mocks base method +func (m *MockEC2API) DescribeClassicLinkInstancesPages(arg0 *ec2.DescribeClassicLinkInstancesInput, arg1 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClassicLinkInstancesPages indicates an expected call of DescribeClassicLinkInstancesPages +func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesPages), arg0, arg1) +} + +// DescribeClassicLinkInstancesPagesWithContext mocks base method +func (m *MockEC2API) DescribeClassicLinkInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClassicLinkInstancesPagesWithContext indicates an expected call of DescribeClassicLinkInstancesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesPagesWithContext), varargs...) +} + +// DescribeClassicLinkInstancesRequest mocks base method +func (m *MockEC2API) DescribeClassicLinkInstancesRequest(arg0 *ec2.DescribeClassicLinkInstancesInput) (*request.Request, *ec2.DescribeClassicLinkInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeClassicLinkInstancesOutput) + return ret0, ret1 +} + +// DescribeClassicLinkInstancesRequest indicates an expected call of DescribeClassicLinkInstancesRequest +func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesRequest), arg0) +} + +// DescribeClassicLinkInstancesWithContext mocks base method +func (m *MockEC2API) DescribeClassicLinkInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 ...request.Option) (*ec2.DescribeClassicLinkInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClassicLinkInstancesWithContext indicates an expected call of DescribeClassicLinkInstancesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesWithContext), varargs...) +} + +// DescribeClientVpnAuthorizationRules mocks base method +func (m *MockEC2API) DescribeClientVpnAuthorizationRules(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRules", arg0) + ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnAuthorizationRules indicates an expected call of DescribeClientVpnAuthorizationRules +func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRules(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRules", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRules), arg0) +} + +// DescribeClientVpnAuthorizationRulesPages mocks base method +func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPages(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput, arg1 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnAuthorizationRulesPages indicates an expected call of DescribeClientVpnAuthorizationRulesPages +func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPages), arg0, arg1) +} + +// DescribeClientVpnAuthorizationRulesPagesWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnAuthorizationRulesPagesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPagesWithContext), varargs...) +} + +// DescribeClientVpnAuthorizationRulesRequest mocks base method +func (m *MockEC2API) DescribeClientVpnAuthorizationRulesRequest(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*request.Request, *ec2.DescribeClientVpnAuthorizationRulesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeClientVpnAuthorizationRulesOutput) + return ret0, ret1 +} + +// DescribeClientVpnAuthorizationRulesRequest indicates an expected call of DescribeClientVpnAuthorizationRulesRequest +func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesRequest), arg0) +} + +// DescribeClientVpnAuthorizationRulesWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnAuthorizationRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnAuthorizationRulesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesWithContext), varargs...) +} + +// DescribeClientVpnConnections mocks base method +func (m *MockEC2API) DescribeClientVpnConnections(arg0 *ec2.DescribeClientVpnConnectionsInput) (*ec2.DescribeClientVpnConnectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnConnections", arg0) + ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnConnections indicates an expected call of DescribeClientVpnConnections +func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnections), arg0) +} + +// DescribeClientVpnConnectionsPages mocks base method +func (m *MockEC2API) DescribeClientVpnConnectionsPages(arg0 *ec2.DescribeClientVpnConnectionsInput, arg1 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnConnectionsPages indicates an expected call of DescribeClientVpnConnectionsPages +func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPages), arg0, arg1) +} + +// DescribeClientVpnConnectionsPagesWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnConnectionsPagesWithContext indicates an expected call of DescribeClientVpnConnectionsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPagesWithContext), varargs...) +} + +// DescribeClientVpnConnectionsRequest mocks base method +func (m *MockEC2API) DescribeClientVpnConnectionsRequest(arg0 *ec2.DescribeClientVpnConnectionsInput) (*request.Request, *ec2.DescribeClientVpnConnectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeClientVpnConnectionsOutput) + return ret0, ret1 +} + +// DescribeClientVpnConnectionsRequest indicates an expected call of DescribeClientVpnConnectionsRequest +func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsRequest), arg0) +} + +// DescribeClientVpnConnectionsWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnConnectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnConnectionsWithContext indicates an expected call of DescribeClientVpnConnectionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsWithContext), varargs...) +} + +// DescribeClientVpnEndpoints mocks base method +func (m *MockEC2API) DescribeClientVpnEndpoints(arg0 *ec2.DescribeClientVpnEndpointsInput) (*ec2.DescribeClientVpnEndpointsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnEndpoints", arg0) + ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnEndpoints indicates an expected call of DescribeClientVpnEndpoints +func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpoints(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpoints), arg0) +} + +// DescribeClientVpnEndpointsPages mocks base method +func (m *MockEC2API) DescribeClientVpnEndpointsPages(arg0 *ec2.DescribeClientVpnEndpointsInput, arg1 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnEndpointsPages indicates an expected call of DescribeClientVpnEndpointsPages +func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsPages), arg0, arg1) +} + +// DescribeClientVpnEndpointsPagesWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnEndpointsPagesWithContext indicates an expected call of DescribeClientVpnEndpointsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsPagesWithContext), varargs...) +} + +// DescribeClientVpnEndpointsRequest mocks base method +func (m *MockEC2API) DescribeClientVpnEndpointsRequest(arg0 *ec2.DescribeClientVpnEndpointsInput) (*request.Request, *ec2.DescribeClientVpnEndpointsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeClientVpnEndpointsOutput) + return ret0, ret1 +} + +// DescribeClientVpnEndpointsRequest indicates an expected call of DescribeClientVpnEndpointsRequest +func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsRequest), arg0) +} + +// DescribeClientVpnEndpointsWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnEndpointsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnEndpointsWithContext indicates an expected call of DescribeClientVpnEndpointsWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsWithContext), varargs...) +} + +// DescribeClientVpnRoutes mocks base method +func (m *MockEC2API) DescribeClientVpnRoutes(arg0 *ec2.DescribeClientVpnRoutesInput) (*ec2.DescribeClientVpnRoutesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnRoutes", arg0) + ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnRoutes indicates an expected call of DescribeClientVpnRoutes +func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutes", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutes), arg0) +} + +// DescribeClientVpnRoutesPages mocks base method +func (m *MockEC2API) DescribeClientVpnRoutesPages(arg0 *ec2.DescribeClientVpnRoutesInput, arg1 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnRoutesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnRoutesPages indicates an expected call of DescribeClientVpnRoutesPages +func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesPages), arg0, arg1) +} + +// DescribeClientVpnRoutesPagesWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnRoutesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnRoutesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnRoutesPagesWithContext indicates an expected call of DescribeClientVpnRoutesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesPagesWithContext), varargs...) +} + +// DescribeClientVpnRoutesRequest mocks base method +func (m *MockEC2API) DescribeClientVpnRoutesRequest(arg0 *ec2.DescribeClientVpnRoutesInput) (*request.Request, *ec2.DescribeClientVpnRoutesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnRoutesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeClientVpnRoutesOutput) + return ret0, ret1 +} + +// DescribeClientVpnRoutesRequest indicates an expected call of DescribeClientVpnRoutesRequest +func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesRequest), arg0) +} + +// DescribeClientVpnRoutesWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnRoutesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnRoutesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnRoutesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnRoutesWithContext indicates an expected call of DescribeClientVpnRoutesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesWithContext), varargs...) +} + +// DescribeClientVpnTargetNetworks mocks base method +func (m *MockEC2API) DescribeClientVpnTargetNetworks(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*ec2.DescribeClientVpnTargetNetworksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworks", arg0) + ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnTargetNetworks indicates an expected call of DescribeClientVpnTargetNetworks +func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworks", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworks), arg0) +} + +// DescribeClientVpnTargetNetworksPages mocks base method +func (m *MockEC2API) DescribeClientVpnTargetNetworksPages(arg0 *ec2.DescribeClientVpnTargetNetworksInput, arg1 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnTargetNetworksPages indicates an expected call of DescribeClientVpnTargetNetworksPages +func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPages), arg0, arg1) +} + +// DescribeClientVpnTargetNetworksPagesWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnTargetNetworksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeClientVpnTargetNetworksPagesWithContext indicates an expected call of DescribeClientVpnTargetNetworksPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPagesWithContext), varargs...) +} + +// DescribeClientVpnTargetNetworksRequest mocks base method +func (m *MockEC2API) DescribeClientVpnTargetNetworksRequest(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*request.Request, *ec2.DescribeClientVpnTargetNetworksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeClientVpnTargetNetworksOutput) + return ret0, ret1 +} + +// DescribeClientVpnTargetNetworksRequest indicates an expected call of DescribeClientVpnTargetNetworksRequest +func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksRequest), arg0) +} + +// DescribeClientVpnTargetNetworksWithContext mocks base method +func (m *MockEC2API) DescribeClientVpnTargetNetworksWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 ...request.Option) (*ec2.DescribeClientVpnTargetNetworksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeClientVpnTargetNetworksWithContext indicates an expected call of DescribeClientVpnTargetNetworksWithContext +func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksWithContext), varargs...) +} + +// DescribeCoipPools mocks base method +func (m *MockEC2API) DescribeCoipPools(arg0 *ec2.DescribeCoipPoolsInput) (*ec2.DescribeCoipPoolsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCoipPools", arg0) + ret0, _ := ret[0].(*ec2.DescribeCoipPoolsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCoipPools indicates an expected call of DescribeCoipPools +func (mr *MockEC2APIMockRecorder) DescribeCoipPools(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPools", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPools), arg0) +} + +// DescribeCoipPoolsPages mocks base method +func (m *MockEC2API) DescribeCoipPoolsPages(arg0 *ec2.DescribeCoipPoolsInput, arg1 func(*ec2.DescribeCoipPoolsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCoipPoolsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCoipPoolsPages indicates an expected call of DescribeCoipPoolsPages +func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsPages), arg0, arg1) +} + +// DescribeCoipPoolsPagesWithContext mocks base method +func (m *MockEC2API) DescribeCoipPoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCoipPoolsInput, arg2 func(*ec2.DescribeCoipPoolsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCoipPoolsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCoipPoolsPagesWithContext indicates an expected call of DescribeCoipPoolsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsPagesWithContext), varargs...) +} + +// DescribeCoipPoolsRequest mocks base method +func (m *MockEC2API) DescribeCoipPoolsRequest(arg0 *ec2.DescribeCoipPoolsInput) (*request.Request, *ec2.DescribeCoipPoolsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCoipPoolsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeCoipPoolsOutput) + return ret0, ret1 +} + +// DescribeCoipPoolsRequest indicates an expected call of DescribeCoipPoolsRequest +func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsRequest), arg0) +} + +// DescribeCoipPoolsWithContext mocks base method +func (m *MockEC2API) DescribeCoipPoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeCoipPoolsInput, arg2 ...request.Option) (*ec2.DescribeCoipPoolsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCoipPoolsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeCoipPoolsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCoipPoolsWithContext indicates an expected call of DescribeCoipPoolsWithContext +func (mr *MockEC2APIMockRecorder) DescribeCoipPoolsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsWithContext), varargs...) +} + +// DescribeConversionTasks mocks base method +func (m *MockEC2API) DescribeConversionTasks(arg0 *ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConversionTasks", arg0) + ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConversionTasks indicates an expected call of DescribeConversionTasks +func (mr *MockEC2APIMockRecorder) DescribeConversionTasks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasks), arg0) +} + +// DescribeConversionTasksRequest mocks base method +func (m *MockEC2API) DescribeConversionTasksRequest(arg0 *ec2.DescribeConversionTasksInput) (*request.Request, *ec2.DescribeConversionTasksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeConversionTasksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeConversionTasksOutput) + return ret0, ret1 +} + +// DescribeConversionTasksRequest indicates an expected call of DescribeConversionTasksRequest +func (mr *MockEC2APIMockRecorder) DescribeConversionTasksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksRequest), arg0) +} + +// DescribeConversionTasksWithContext mocks base method +func (m *MockEC2API) DescribeConversionTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.Option) (*ec2.DescribeConversionTasksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeConversionTasksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeConversionTasksWithContext indicates an expected call of DescribeConversionTasksWithContext +func (mr *MockEC2APIMockRecorder) DescribeConversionTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksWithContext), varargs...) +} + +// DescribeCustomerGateways mocks base method +func (m *MockEC2API) DescribeCustomerGateways(arg0 *ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCustomerGateways", arg0) + ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCustomerGateways indicates an expected call of DescribeCustomerGateways +func (mr *MockEC2APIMockRecorder) DescribeCustomerGateways(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGateways), arg0) +} + +// DescribeCustomerGatewaysRequest mocks base method +func (m *MockEC2API) DescribeCustomerGatewaysRequest(arg0 *ec2.DescribeCustomerGatewaysInput) (*request.Request, *ec2.DescribeCustomerGatewaysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCustomerGatewaysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeCustomerGatewaysOutput) + return ret0, ret1 +} + +// DescribeCustomerGatewaysRequest indicates an expected call of DescribeCustomerGatewaysRequest +func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysRequest), arg0) +} + +// DescribeCustomerGatewaysWithContext mocks base method +func (m *MockEC2API) DescribeCustomerGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCustomerGatewaysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCustomerGatewaysWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCustomerGatewaysWithContext indicates an expected call of DescribeCustomerGatewaysWithContext +func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysWithContext), varargs...) +} + +// DescribeDhcpOptions mocks base method +func (m *MockEC2API) DescribeDhcpOptions(arg0 *ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeDhcpOptions", arg0) + ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeDhcpOptions indicates an expected call of DescribeDhcpOptions +func (mr *MockEC2APIMockRecorder) DescribeDhcpOptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptions), arg0) +} + +// DescribeDhcpOptionsPages mocks base method +func (m *MockEC2API) DescribeDhcpOptionsPages(arg0 *ec2.DescribeDhcpOptionsInput, arg1 func(*ec2.DescribeDhcpOptionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeDhcpOptionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeDhcpOptionsPages indicates an expected call of DescribeDhcpOptionsPages +func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsPages), arg0, arg1) +} + +// DescribeDhcpOptionsPagesWithContext mocks base method +func (m *MockEC2API) DescribeDhcpOptionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 func(*ec2.DescribeDhcpOptionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeDhcpOptionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeDhcpOptionsPagesWithContext indicates an expected call of DescribeDhcpOptionsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsPagesWithContext), varargs...) +} + +// DescribeDhcpOptionsRequest mocks base method +func (m *MockEC2API) DescribeDhcpOptionsRequest(arg0 *ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeDhcpOptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeDhcpOptionsOutput) + return ret0, ret1 +} + +// DescribeDhcpOptionsRequest indicates an expected call of DescribeDhcpOptionsRequest +func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsRequest), arg0) +} + +// DescribeDhcpOptionsWithContext mocks base method +func (m *MockEC2API) DescribeDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 ...request.Option) (*ec2.DescribeDhcpOptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeDhcpOptionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeDhcpOptionsWithContext indicates an expected call of DescribeDhcpOptionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsWithContext), varargs...) +} + +// DescribeEgressOnlyInternetGateways mocks base method +func (m *MockEC2API) DescribeEgressOnlyInternetGateways(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGateways", arg0) + ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEgressOnlyInternetGateways indicates an expected call of DescribeEgressOnlyInternetGateways +func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGateways(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGateways), arg0) +} + +// DescribeEgressOnlyInternetGatewaysPages mocks base method +func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPages(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg1 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEgressOnlyInternetGatewaysPages indicates an expected call of DescribeEgressOnlyInternetGatewaysPages +func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPages), arg0, arg1) +} + +// DescribeEgressOnlyInternetGatewaysPagesWithContext mocks base method +func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEgressOnlyInternetGatewaysPagesWithContext indicates an expected call of DescribeEgressOnlyInternetGatewaysPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPagesWithContext), varargs...) +} + +// DescribeEgressOnlyInternetGatewaysRequest mocks base method +func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysRequest(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*request.Request, *ec2.DescribeEgressOnlyInternetGatewaysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) + return ret0, ret1 +} + +// DescribeEgressOnlyInternetGatewaysRequest indicates an expected call of DescribeEgressOnlyInternetGatewaysRequest +func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysRequest), arg0) +} + +// DescribeEgressOnlyInternetGatewaysWithContext mocks base method +func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEgressOnlyInternetGatewaysWithContext indicates an expected call of DescribeEgressOnlyInternetGatewaysWithContext +func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysWithContext), varargs...) +} + +// DescribeElasticGpus mocks base method +func (m *MockEC2API) DescribeElasticGpus(arg0 *ec2.DescribeElasticGpusInput) (*ec2.DescribeElasticGpusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeElasticGpus", arg0) + ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeElasticGpus indicates an expected call of DescribeElasticGpus +func (mr *MockEC2APIMockRecorder) DescribeElasticGpus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpus", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpus), arg0) +} + +// DescribeElasticGpusRequest mocks base method +func (m *MockEC2API) DescribeElasticGpusRequest(arg0 *ec2.DescribeElasticGpusInput) (*request.Request, *ec2.DescribeElasticGpusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeElasticGpusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeElasticGpusOutput) + return ret0, ret1 +} + +// DescribeElasticGpusRequest indicates an expected call of DescribeElasticGpusRequest +func (mr *MockEC2APIMockRecorder) DescribeElasticGpusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpusRequest), arg0) +} + +// DescribeElasticGpusWithContext mocks base method +func (m *MockEC2API) DescribeElasticGpusWithContext(arg0 context.Context, arg1 *ec2.DescribeElasticGpusInput, arg2 ...request.Option) (*ec2.DescribeElasticGpusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeElasticGpusWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeElasticGpusWithContext indicates an expected call of DescribeElasticGpusWithContext +func (mr *MockEC2APIMockRecorder) DescribeElasticGpusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpusWithContext), varargs...) +} + +// DescribeExportImageTasks mocks base method +func (m *MockEC2API) DescribeExportImageTasks(arg0 *ec2.DescribeExportImageTasksInput) (*ec2.DescribeExportImageTasksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExportImageTasks", arg0) + ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeExportImageTasks indicates an expected call of DescribeExportImageTasks +func (mr *MockEC2APIMockRecorder) DescribeExportImageTasks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasks), arg0) +} + +// DescribeExportImageTasksPages mocks base method +func (m *MockEC2API) DescribeExportImageTasksPages(arg0 *ec2.DescribeExportImageTasksInput, arg1 func(*ec2.DescribeExportImageTasksOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExportImageTasksPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeExportImageTasksPages indicates an expected call of DescribeExportImageTasksPages +func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksPages), arg0, arg1) +} + +// DescribeExportImageTasksPagesWithContext mocks base method +func (m *MockEC2API) DescribeExportImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 func(*ec2.DescribeExportImageTasksOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeExportImageTasksPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeExportImageTasksPagesWithContext indicates an expected call of DescribeExportImageTasksPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksPagesWithContext), varargs...) +} + +// DescribeExportImageTasksRequest mocks base method +func (m *MockEC2API) DescribeExportImageTasksRequest(arg0 *ec2.DescribeExportImageTasksInput) (*request.Request, *ec2.DescribeExportImageTasksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExportImageTasksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeExportImageTasksOutput) + return ret0, ret1 +} + +// DescribeExportImageTasksRequest indicates an expected call of DescribeExportImageTasksRequest +func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksRequest), arg0) +} + +// DescribeExportImageTasksWithContext mocks base method +func (m *MockEC2API) DescribeExportImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeExportImageTasksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeExportImageTasksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeExportImageTasksWithContext indicates an expected call of DescribeExportImageTasksWithContext +func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksWithContext), varargs...) +} + +// DescribeExportTasks mocks base method +func (m *MockEC2API) DescribeExportTasks(arg0 *ec2.DescribeExportTasksInput) (*ec2.DescribeExportTasksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExportTasks", arg0) + ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeExportTasks indicates an expected call of DescribeExportTasks +func (mr *MockEC2APIMockRecorder) DescribeExportTasks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasks), arg0) +} + +// DescribeExportTasksRequest mocks base method +func (m *MockEC2API) DescribeExportTasksRequest(arg0 *ec2.DescribeExportTasksInput) (*request.Request, *ec2.DescribeExportTasksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExportTasksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeExportTasksOutput) + return ret0, ret1 +} + +// DescribeExportTasksRequest indicates an expected call of DescribeExportTasksRequest +func (mr *MockEC2APIMockRecorder) DescribeExportTasksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasksRequest), arg0) +} + +// DescribeExportTasksWithContext mocks base method +func (m *MockEC2API) DescribeExportTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.Option) (*ec2.DescribeExportTasksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeExportTasksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeExportTasksWithContext indicates an expected call of DescribeExportTasksWithContext +func (mr *MockEC2APIMockRecorder) DescribeExportTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasksWithContext), varargs...) +} + +// DescribeFastSnapshotRestores mocks base method +func (m *MockEC2API) DescribeFastSnapshotRestores(arg0 *ec2.DescribeFastSnapshotRestoresInput) (*ec2.DescribeFastSnapshotRestoresOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFastSnapshotRestores", arg0) + ret0, _ := ret[0].(*ec2.DescribeFastSnapshotRestoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFastSnapshotRestores indicates an expected call of DescribeFastSnapshotRestores +func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestores(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestores), arg0) +} + +// DescribeFastSnapshotRestoresPages mocks base method +func (m *MockEC2API) DescribeFastSnapshotRestoresPages(arg0 *ec2.DescribeFastSnapshotRestoresInput, arg1 func(*ec2.DescribeFastSnapshotRestoresOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFastSnapshotRestoresPages indicates an expected call of DescribeFastSnapshotRestoresPages +func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresPages), arg0, arg1) +} + +// DescribeFastSnapshotRestoresPagesWithContext mocks base method +func (m *MockEC2API) DescribeFastSnapshotRestoresPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastSnapshotRestoresInput, arg2 func(*ec2.DescribeFastSnapshotRestoresOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFastSnapshotRestoresPagesWithContext indicates an expected call of DescribeFastSnapshotRestoresPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresPagesWithContext), varargs...) +} + +// DescribeFastSnapshotRestoresRequest mocks base method +func (m *MockEC2API) DescribeFastSnapshotRestoresRequest(arg0 *ec2.DescribeFastSnapshotRestoresInput) (*request.Request, *ec2.DescribeFastSnapshotRestoresOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeFastSnapshotRestoresOutput) + return ret0, ret1 +} + +// DescribeFastSnapshotRestoresRequest indicates an expected call of DescribeFastSnapshotRestoresRequest +func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresRequest), arg0) +} + +// DescribeFastSnapshotRestoresWithContext mocks base method +func (m *MockEC2API) DescribeFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.DescribeFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.DescribeFastSnapshotRestoresOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeFastSnapshotRestoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFastSnapshotRestoresWithContext indicates an expected call of DescribeFastSnapshotRestoresWithContext +func (mr *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresWithContext), varargs...) +} + +// DescribeFleetHistory mocks base method +func (m *MockEC2API) DescribeFleetHistory(arg0 *ec2.DescribeFleetHistoryInput) (*ec2.DescribeFleetHistoryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetHistory", arg0) + ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetHistory indicates an expected call of DescribeFleetHistory +func (mr *MockEC2APIMockRecorder) DescribeFleetHistory(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistory), arg0) +} + +// DescribeFleetHistoryRequest mocks base method +func (m *MockEC2API) DescribeFleetHistoryRequest(arg0 *ec2.DescribeFleetHistoryInput) (*request.Request, *ec2.DescribeFleetHistoryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetHistoryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeFleetHistoryOutput) + return ret0, ret1 +} + +// DescribeFleetHistoryRequest indicates an expected call of DescribeFleetHistoryRequest +func (mr *MockEC2APIMockRecorder) DescribeFleetHistoryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistoryRequest), arg0) +} + +// DescribeFleetHistoryWithContext mocks base method +func (m *MockEC2API) DescribeFleetHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetHistoryInput, arg2 ...request.Option) (*ec2.DescribeFleetHistoryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetHistoryWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetHistoryWithContext indicates an expected call of DescribeFleetHistoryWithContext +func (mr *MockEC2APIMockRecorder) DescribeFleetHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistoryWithContext), varargs...) +} + +// DescribeFleetInstances mocks base method +func (m *MockEC2API) DescribeFleetInstances(arg0 *ec2.DescribeFleetInstancesInput) (*ec2.DescribeFleetInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetInstances", arg0) + ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetInstances indicates an expected call of DescribeFleetInstances +func (mr *MockEC2APIMockRecorder) DescribeFleetInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstances), arg0) +} + +// DescribeFleetInstancesRequest mocks base method +func (m *MockEC2API) DescribeFleetInstancesRequest(arg0 *ec2.DescribeFleetInstancesInput) (*request.Request, *ec2.DescribeFleetInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeFleetInstancesOutput) + return ret0, ret1 +} + +// DescribeFleetInstancesRequest indicates an expected call of DescribeFleetInstancesRequest +func (mr *MockEC2APIMockRecorder) DescribeFleetInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstancesRequest), arg0) +} + +// DescribeFleetInstancesWithContext mocks base method +func (m *MockEC2API) DescribeFleetInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeFleetInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetInstancesWithContext indicates an expected call of DescribeFleetInstancesWithContext +func (mr *MockEC2APIMockRecorder) DescribeFleetInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstancesWithContext), varargs...) +} + +// DescribeFleets mocks base method +func (m *MockEC2API) DescribeFleets(arg0 *ec2.DescribeFleetsInput) (*ec2.DescribeFleetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleets", arg0) + ret0, _ := ret[0].(*ec2.DescribeFleetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleets indicates an expected call of DescribeFleets +func (mr *MockEC2APIMockRecorder) DescribeFleets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleets", reflect.TypeOf((*MockEC2API)(nil).DescribeFleets), arg0) +} + +// DescribeFleetsPages mocks base method +func (m *MockEC2API) DescribeFleetsPages(arg0 *ec2.DescribeFleetsInput, arg1 func(*ec2.DescribeFleetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetsPages indicates an expected call of DescribeFleetsPages +func (mr *MockEC2APIMockRecorder) DescribeFleetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsPages), arg0, arg1) +} + +// DescribeFleetsPagesWithContext mocks base method +func (m *MockEC2API) DescribeFleetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetsInput, arg2 func(*ec2.DescribeFleetsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFleetsPagesWithContext indicates an expected call of DescribeFleetsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeFleetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsPagesWithContext), varargs...) +} + +// DescribeFleetsRequest mocks base method +func (m *MockEC2API) DescribeFleetsRequest(arg0 *ec2.DescribeFleetsInput) (*request.Request, *ec2.DescribeFleetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFleetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeFleetsOutput) + return ret0, ret1 +} + +// DescribeFleetsRequest indicates an expected call of DescribeFleetsRequest +func (mr *MockEC2APIMockRecorder) DescribeFleetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsRequest), arg0) +} + +// DescribeFleetsWithContext mocks base method +func (m *MockEC2API) DescribeFleetsWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetsInput, arg2 ...request.Option) (*ec2.DescribeFleetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFleetsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeFleetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFleetsWithContext indicates an expected call of DescribeFleetsWithContext +func (mr *MockEC2APIMockRecorder) DescribeFleetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsWithContext), varargs...) +} + +// DescribeFlowLogs mocks base method +func (m *MockEC2API) DescribeFlowLogs(arg0 *ec2.DescribeFlowLogsInput) (*ec2.DescribeFlowLogsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFlowLogs", arg0) + ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFlowLogs indicates an expected call of DescribeFlowLogs +func (mr *MockEC2APIMockRecorder) DescribeFlowLogs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogs), arg0) +} + +// DescribeFlowLogsPages mocks base method +func (m *MockEC2API) DescribeFlowLogsPages(arg0 *ec2.DescribeFlowLogsInput, arg1 func(*ec2.DescribeFlowLogsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFlowLogsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFlowLogsPages indicates an expected call of DescribeFlowLogsPages +func (mr *MockEC2APIMockRecorder) DescribeFlowLogsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsPages), arg0, arg1) +} + +// DescribeFlowLogsPagesWithContext mocks base method +func (m *MockEC2API) DescribeFlowLogsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 func(*ec2.DescribeFlowLogsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFlowLogsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFlowLogsPagesWithContext indicates an expected call of DescribeFlowLogsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeFlowLogsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsPagesWithContext), varargs...) +} + +// DescribeFlowLogsRequest mocks base method +func (m *MockEC2API) DescribeFlowLogsRequest(arg0 *ec2.DescribeFlowLogsInput) (*request.Request, *ec2.DescribeFlowLogsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFlowLogsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeFlowLogsOutput) + return ret0, ret1 +} + +// DescribeFlowLogsRequest indicates an expected call of DescribeFlowLogsRequest +func (mr *MockEC2APIMockRecorder) DescribeFlowLogsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsRequest), arg0) +} + +// DescribeFlowLogsWithContext mocks base method +func (m *MockEC2API) DescribeFlowLogsWithContext(arg0 context.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 ...request.Option) (*ec2.DescribeFlowLogsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFlowLogsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFlowLogsWithContext indicates an expected call of DescribeFlowLogsWithContext +func (mr *MockEC2APIMockRecorder) DescribeFlowLogsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsWithContext), varargs...) +} + +// DescribeFpgaImageAttribute mocks base method +func (m *MockEC2API) DescribeFpgaImageAttribute(arg0 *ec2.DescribeFpgaImageAttributeInput) (*ec2.DescribeFpgaImageAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFpgaImageAttribute", arg0) + ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFpgaImageAttribute indicates an expected call of DescribeFpgaImageAttribute +func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttribute), arg0) +} + +// DescribeFpgaImageAttributeRequest mocks base method +func (m *MockEC2API) DescribeFpgaImageAttributeRequest(arg0 *ec2.DescribeFpgaImageAttributeInput) (*request.Request, *ec2.DescribeFpgaImageAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeFpgaImageAttributeOutput) + return ret0, ret1 +} + +// DescribeFpgaImageAttributeRequest indicates an expected call of DescribeFpgaImageAttributeRequest +func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttributeRequest), arg0) +} + +// DescribeFpgaImageAttributeWithContext mocks base method +func (m *MockEC2API) DescribeFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeFpgaImageAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFpgaImageAttributeWithContext indicates an expected call of DescribeFpgaImageAttributeWithContext +func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttributeWithContext), varargs...) +} + +// DescribeFpgaImages mocks base method +func (m *MockEC2API) DescribeFpgaImages(arg0 *ec2.DescribeFpgaImagesInput) (*ec2.DescribeFpgaImagesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFpgaImages", arg0) + ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFpgaImages indicates an expected call of DescribeFpgaImages +func (mr *MockEC2APIMockRecorder) DescribeFpgaImages(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImages), arg0) +} + +// DescribeFpgaImagesPages mocks base method +func (m *MockEC2API) DescribeFpgaImagesPages(arg0 *ec2.DescribeFpgaImagesInput, arg1 func(*ec2.DescribeFpgaImagesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFpgaImagesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFpgaImagesPages indicates an expected call of DescribeFpgaImagesPages +func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesPages), arg0, arg1) +} + +// DescribeFpgaImagesPagesWithContext mocks base method +func (m *MockEC2API) DescribeFpgaImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 func(*ec2.DescribeFpgaImagesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFpgaImagesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeFpgaImagesPagesWithContext indicates an expected call of DescribeFpgaImagesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesPagesWithContext), varargs...) +} + +// DescribeFpgaImagesRequest mocks base method +func (m *MockEC2API) DescribeFpgaImagesRequest(arg0 *ec2.DescribeFpgaImagesInput) (*request.Request, *ec2.DescribeFpgaImagesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFpgaImagesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeFpgaImagesOutput) + return ret0, ret1 +} + +// DescribeFpgaImagesRequest indicates an expected call of DescribeFpgaImagesRequest +func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesRequest), arg0) +} + +// DescribeFpgaImagesWithContext mocks base method +func (m *MockEC2API) DescribeFpgaImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 ...request.Option) (*ec2.DescribeFpgaImagesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFpgaImagesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFpgaImagesWithContext indicates an expected call of DescribeFpgaImagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesWithContext), varargs...) +} + +// DescribeHostReservationOfferings mocks base method +func (m *MockEC2API) DescribeHostReservationOfferings(arg0 *ec2.DescribeHostReservationOfferingsInput) (*ec2.DescribeHostReservationOfferingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHostReservationOfferings", arg0) + ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeHostReservationOfferings indicates an expected call of DescribeHostReservationOfferings +func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferings), arg0) +} + +// DescribeHostReservationOfferingsPages mocks base method +func (m *MockEC2API) DescribeHostReservationOfferingsPages(arg0 *ec2.DescribeHostReservationOfferingsInput, arg1 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeHostReservationOfferingsPages indicates an expected call of DescribeHostReservationOfferingsPages +func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsPages), arg0, arg1) +} + +// DescribeHostReservationOfferingsPagesWithContext mocks base method +func (m *MockEC2API) DescribeHostReservationOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeHostReservationOfferingsPagesWithContext indicates an expected call of DescribeHostReservationOfferingsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsPagesWithContext), varargs...) +} + +// DescribeHostReservationOfferingsRequest mocks base method +func (m *MockEC2API) DescribeHostReservationOfferingsRequest(arg0 *ec2.DescribeHostReservationOfferingsInput) (*request.Request, *ec2.DescribeHostReservationOfferingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeHostReservationOfferingsOutput) + return ret0, ret1 +} + +// DescribeHostReservationOfferingsRequest indicates an expected call of DescribeHostReservationOfferingsRequest +func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsRequest), arg0) +} + +// DescribeHostReservationOfferingsWithContext mocks base method +func (m *MockEC2API) DescribeHostReservationOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationOfferingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeHostReservationOfferingsWithContext indicates an expected call of DescribeHostReservationOfferingsWithContext +func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsWithContext), varargs...) +} + +// DescribeHostReservations mocks base method +func (m *MockEC2API) DescribeHostReservations(arg0 *ec2.DescribeHostReservationsInput) (*ec2.DescribeHostReservationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHostReservations", arg0) + ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeHostReservations indicates an expected call of DescribeHostReservations +func (mr *MockEC2APIMockRecorder) DescribeHostReservations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservations), arg0) +} + +// DescribeHostReservationsPages mocks base method +func (m *MockEC2API) DescribeHostReservationsPages(arg0 *ec2.DescribeHostReservationsInput, arg1 func(*ec2.DescribeHostReservationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHostReservationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeHostReservationsPages indicates an expected call of DescribeHostReservationsPages +func (mr *MockEC2APIMockRecorder) DescribeHostReservationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsPages), arg0, arg1) +} + +// DescribeHostReservationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeHostReservationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 func(*ec2.DescribeHostReservationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeHostReservationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeHostReservationsPagesWithContext indicates an expected call of DescribeHostReservationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeHostReservationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsPagesWithContext), varargs...) +} + +// DescribeHostReservationsRequest mocks base method +func (m *MockEC2API) DescribeHostReservationsRequest(arg0 *ec2.DescribeHostReservationsInput) (*request.Request, *ec2.DescribeHostReservationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHostReservationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeHostReservationsOutput) + return ret0, ret1 +} + +// DescribeHostReservationsRequest indicates an expected call of DescribeHostReservationsRequest +func (mr *MockEC2APIMockRecorder) DescribeHostReservationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsRequest), arg0) +} + +// DescribeHostReservationsWithContext mocks base method +func (m *MockEC2API) DescribeHostReservationsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeHostReservationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeHostReservationsWithContext indicates an expected call of DescribeHostReservationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeHostReservationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsWithContext), varargs...) +} + +// DescribeHosts mocks base method +func (m *MockEC2API) DescribeHosts(arg0 *ec2.DescribeHostsInput) (*ec2.DescribeHostsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHosts", arg0) + ret0, _ := ret[0].(*ec2.DescribeHostsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeHosts indicates an expected call of DescribeHosts +func (mr *MockEC2APIMockRecorder) DescribeHosts(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHosts", reflect.TypeOf((*MockEC2API)(nil).DescribeHosts), arg0) +} + +// DescribeHostsPages mocks base method +func (m *MockEC2API) DescribeHostsPages(arg0 *ec2.DescribeHostsInput, arg1 func(*ec2.DescribeHostsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHostsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeHostsPages indicates an expected call of DescribeHostsPages +func (mr *MockEC2APIMockRecorder) DescribeHostsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsPages), arg0, arg1) +} + +// DescribeHostsPagesWithContext mocks base method +func (m *MockEC2API) DescribeHostsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostsInput, arg2 func(*ec2.DescribeHostsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeHostsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeHostsPagesWithContext indicates an expected call of DescribeHostsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeHostsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsPagesWithContext), varargs...) +} + +// DescribeHostsRequest mocks base method +func (m *MockEC2API) DescribeHostsRequest(arg0 *ec2.DescribeHostsInput) (*request.Request, *ec2.DescribeHostsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHostsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeHostsOutput) + return ret0, ret1 +} + +// DescribeHostsRequest indicates an expected call of DescribeHostsRequest +func (mr *MockEC2APIMockRecorder) DescribeHostsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsRequest), arg0) +} + +// DescribeHostsWithContext mocks base method +func (m *MockEC2API) DescribeHostsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostsInput, arg2 ...request.Option) (*ec2.DescribeHostsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeHostsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeHostsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeHostsWithContext indicates an expected call of DescribeHostsWithContext +func (mr *MockEC2APIMockRecorder) DescribeHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsWithContext), varargs...) +} + +// DescribeIamInstanceProfileAssociations mocks base method +func (m *MockEC2API) DescribeIamInstanceProfileAssociations(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociations", arg0) + ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIamInstanceProfileAssociations indicates an expected call of DescribeIamInstanceProfileAssociations +func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociations), arg0) +} + +// DescribeIamInstanceProfileAssociationsPages mocks base method +func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPages(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput, arg1 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeIamInstanceProfileAssociationsPages indicates an expected call of DescribeIamInstanceProfileAssociationsPages +func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPages), arg0, arg1) +} + +// DescribeIamInstanceProfileAssociationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeIamInstanceProfileAssociationsPagesWithContext indicates an expected call of DescribeIamInstanceProfileAssociationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPagesWithContext), varargs...) +} + +// DescribeIamInstanceProfileAssociationsRequest mocks base method +func (m *MockEC2API) DescribeIamInstanceProfileAssociationsRequest(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*request.Request, *ec2.DescribeIamInstanceProfileAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeIamInstanceProfileAssociationsOutput) + return ret0, ret1 +} + +// DescribeIamInstanceProfileAssociationsRequest indicates an expected call of DescribeIamInstanceProfileAssociationsRequest +func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsRequest), arg0) +} + +// DescribeIamInstanceProfileAssociationsWithContext mocks base method +func (m *MockEC2API) DescribeIamInstanceProfileAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 ...request.Option) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIamInstanceProfileAssociationsWithContext indicates an expected call of DescribeIamInstanceProfileAssociationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsWithContext), varargs...) +} + +// DescribeIdFormat mocks base method +func (m *MockEC2API) DescribeIdFormat(arg0 *ec2.DescribeIdFormatInput) (*ec2.DescribeIdFormatOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIdFormat", arg0) + ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIdFormat indicates an expected call of DescribeIdFormat +func (mr *MockEC2APIMockRecorder) DescribeIdFormat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormat), arg0) +} + +// DescribeIdFormatRequest mocks base method +func (m *MockEC2API) DescribeIdFormatRequest(arg0 *ec2.DescribeIdFormatInput) (*request.Request, *ec2.DescribeIdFormatOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIdFormatRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeIdFormatOutput) + return ret0, ret1 +} + +// DescribeIdFormatRequest indicates an expected call of DescribeIdFormatRequest +func (mr *MockEC2APIMockRecorder) DescribeIdFormatRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormatRequest), arg0) +} + +// DescribeIdFormatWithContext mocks base method +func (m *MockEC2API) DescribeIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdFormatOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeIdFormatWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIdFormatWithContext indicates an expected call of DescribeIdFormatWithContext +func (mr *MockEC2APIMockRecorder) DescribeIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormatWithContext), varargs...) +} + +// DescribeIdentityIdFormat mocks base method +func (m *MockEC2API) DescribeIdentityIdFormat(arg0 *ec2.DescribeIdentityIdFormatInput) (*ec2.DescribeIdentityIdFormatOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIdentityIdFormat", arg0) + ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIdentityIdFormat indicates an expected call of DescribeIdentityIdFormat +func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormat), arg0) +} + +// DescribeIdentityIdFormatRequest mocks base method +func (m *MockEC2API) DescribeIdentityIdFormatRequest(arg0 *ec2.DescribeIdentityIdFormatInput) (*request.Request, *ec2.DescribeIdentityIdFormatOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIdentityIdFormatRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeIdentityIdFormatOutput) + return ret0, ret1 +} + +// DescribeIdentityIdFormatRequest indicates an expected call of DescribeIdentityIdFormatRequest +func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormatRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormatRequest), arg0) +} + +// DescribeIdentityIdFormatWithContext mocks base method +func (m *MockEC2API) DescribeIdentityIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeIdentityIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdentityIdFormatOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeIdentityIdFormatWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIdentityIdFormatWithContext indicates an expected call of DescribeIdentityIdFormatWithContext +func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormatWithContext), varargs...) +} + +// DescribeImageAttribute mocks base method +func (m *MockEC2API) DescribeImageAttribute(arg0 *ec2.DescribeImageAttributeInput) (*ec2.DescribeImageAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImageAttribute", arg0) + ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImageAttribute indicates an expected call of DescribeImageAttribute +func (mr *MockEC2APIMockRecorder) DescribeImageAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttribute), arg0) +} + +// DescribeImageAttributeRequest mocks base method +func (m *MockEC2API) DescribeImageAttributeRequest(arg0 *ec2.DescribeImageAttributeInput) (*request.Request, *ec2.DescribeImageAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImageAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeImageAttributeOutput) + return ret0, ret1 +} + +// DescribeImageAttributeRequest indicates an expected call of DescribeImageAttributeRequest +func (mr *MockEC2APIMockRecorder) DescribeImageAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttributeRequest), arg0) +} + +// DescribeImageAttributeWithContext mocks base method +func (m *MockEC2API) DescribeImageAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeImageAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImageAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImageAttributeWithContext indicates an expected call of DescribeImageAttributeWithContext +func (mr *MockEC2APIMockRecorder) DescribeImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttributeWithContext), varargs...) +} + +// DescribeImages mocks base method +func (m *MockEC2API) DescribeImages(arg0 *ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImages", arg0) + ret0, _ := ret[0].(*ec2.DescribeImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImages indicates an expected call of DescribeImages +func (mr *MockEC2APIMockRecorder) DescribeImages(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockEC2API)(nil).DescribeImages), arg0) +} + +// DescribeImagesRequest mocks base method +func (m *MockEC2API) DescribeImagesRequest(arg0 *ec2.DescribeImagesInput) (*request.Request, *ec2.DescribeImagesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImagesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeImagesOutput) + return ret0, ret1 +} + +// DescribeImagesRequest indicates an expected call of DescribeImagesRequest +func (mr *MockEC2APIMockRecorder) DescribeImagesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesRequest), arg0) +} + +// DescribeImagesWithContext mocks base method +func (m *MockEC2API) DescribeImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.Option) (*ec2.DescribeImagesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImagesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImagesWithContext indicates an expected call of DescribeImagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeImagesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesWithContext), varargs...) +} + +// DescribeImportImageTasks mocks base method +func (m *MockEC2API) DescribeImportImageTasks(arg0 *ec2.DescribeImportImageTasksInput) (*ec2.DescribeImportImageTasksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImportImageTasks", arg0) + ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImportImageTasks indicates an expected call of DescribeImportImageTasks +func (mr *MockEC2APIMockRecorder) DescribeImportImageTasks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasks), arg0) +} + +// DescribeImportImageTasksPages mocks base method +func (m *MockEC2API) DescribeImportImageTasksPages(arg0 *ec2.DescribeImportImageTasksInput, arg1 func(*ec2.DescribeImportImageTasksOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImportImageTasksPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeImportImageTasksPages indicates an expected call of DescribeImportImageTasksPages +func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPages), arg0, arg1) +} + +// DescribeImportImageTasksPagesWithContext mocks base method +func (m *MockEC2API) DescribeImportImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 func(*ec2.DescribeImportImageTasksOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImportImageTasksPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeImportImageTasksPagesWithContext indicates an expected call of DescribeImportImageTasksPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPagesWithContext), varargs...) +} + +// DescribeImportImageTasksRequest mocks base method +func (m *MockEC2API) DescribeImportImageTasksRequest(arg0 *ec2.DescribeImportImageTasksInput) (*request.Request, *ec2.DescribeImportImageTasksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImportImageTasksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeImportImageTasksOutput) + return ret0, ret1 +} + +// DescribeImportImageTasksRequest indicates an expected call of DescribeImportImageTasksRequest +func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksRequest), arg0) +} + +// DescribeImportImageTasksWithContext mocks base method +func (m *MockEC2API) DescribeImportImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeImportImageTasksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImportImageTasksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImportImageTasksWithContext indicates an expected call of DescribeImportImageTasksWithContext +func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksWithContext), varargs...) +} + +// DescribeImportSnapshotTasks mocks base method +func (m *MockEC2API) DescribeImportSnapshotTasks(arg0 *ec2.DescribeImportSnapshotTasksInput) (*ec2.DescribeImportSnapshotTasksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImportSnapshotTasks", arg0) + ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImportSnapshotTasks indicates an expected call of DescribeImportSnapshotTasks +func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasks), arg0) +} + +// DescribeImportSnapshotTasksPages mocks base method +func (m *MockEC2API) DescribeImportSnapshotTasksPages(arg0 *ec2.DescribeImportSnapshotTasksInput, arg1 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeImportSnapshotTasksPages indicates an expected call of DescribeImportSnapshotTasksPages +func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksPages), arg0, arg1) +} + +// DescribeImportSnapshotTasksPagesWithContext mocks base method +func (m *MockEC2API) DescribeImportSnapshotTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeImportSnapshotTasksPagesWithContext indicates an expected call of DescribeImportSnapshotTasksPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksPagesWithContext), varargs...) +} + +// DescribeImportSnapshotTasksRequest mocks base method +func (m *MockEC2API) DescribeImportSnapshotTasksRequest(arg0 *ec2.DescribeImportSnapshotTasksInput) (*request.Request, *ec2.DescribeImportSnapshotTasksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeImportSnapshotTasksOutput) + return ret0, ret1 +} + +// DescribeImportSnapshotTasksRequest indicates an expected call of DescribeImportSnapshotTasksRequest +func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksRequest), arg0) +} + +// DescribeImportSnapshotTasksWithContext mocks base method +func (m *MockEC2API) DescribeImportSnapshotTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 ...request.Option) (*ec2.DescribeImportSnapshotTasksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImportSnapshotTasksWithContext indicates an expected call of DescribeImportSnapshotTasksWithContext +func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksWithContext), varargs...) +} + +// DescribeInstanceAttribute mocks base method +func (m *MockEC2API) DescribeInstanceAttribute(arg0 *ec2.DescribeInstanceAttributeInput) (*ec2.DescribeInstanceAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceAttribute", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceAttribute indicates an expected call of DescribeInstanceAttribute +func (mr *MockEC2APIMockRecorder) DescribeInstanceAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttribute), arg0) +} + +// DescribeInstanceAttributeRequest mocks base method +func (m *MockEC2API) DescribeInstanceAttributeRequest(arg0 *ec2.DescribeInstanceAttributeInput) (*request.Request, *ec2.DescribeInstanceAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeInstanceAttributeOutput) + return ret0, ret1 +} + +// DescribeInstanceAttributeRequest indicates an expected call of DescribeInstanceAttributeRequest +func (mr *MockEC2APIMockRecorder) DescribeInstanceAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttributeRequest), arg0) +} + +// DescribeInstanceAttributeWithContext mocks base method +func (m *MockEC2API) DescribeInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceAttributeInput, arg2 ...request.Option) (*ec2.DescribeInstanceAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceAttributeWithContext indicates an expected call of DescribeInstanceAttributeWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttributeWithContext), varargs...) +} + +// DescribeInstanceCreditSpecifications mocks base method +func (m *MockEC2API) DescribeInstanceCreditSpecifications(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecifications", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceCreditSpecifications indicates an expected call of DescribeInstanceCreditSpecifications +func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecifications(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecifications", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecifications), arg0) +} + +// DescribeInstanceCreditSpecificationsPages mocks base method +func (m *MockEC2API) DescribeInstanceCreditSpecificationsPages(arg0 *ec2.DescribeInstanceCreditSpecificationsInput, arg1 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceCreditSpecificationsPages indicates an expected call of DescribeInstanceCreditSpecificationsPages +func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPages), arg0, arg1) +} + +// DescribeInstanceCreditSpecificationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeInstanceCreditSpecificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceCreditSpecificationsPagesWithContext indicates an expected call of DescribeInstanceCreditSpecificationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPagesWithContext), varargs...) +} + +// DescribeInstanceCreditSpecificationsRequest mocks base method +func (m *MockEC2API) DescribeInstanceCreditSpecificationsRequest(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*request.Request, *ec2.DescribeInstanceCreditSpecificationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeInstanceCreditSpecificationsOutput) + return ret0, ret1 +} + +// DescribeInstanceCreditSpecificationsRequest indicates an expected call of DescribeInstanceCreditSpecificationsRequest +func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsRequest), arg0) +} + +// DescribeInstanceCreditSpecificationsWithContext mocks base method +func (m *MockEC2API) DescribeInstanceCreditSpecificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 ...request.Option) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceCreditSpecificationsWithContext indicates an expected call of DescribeInstanceCreditSpecificationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsWithContext), varargs...) +} + +// DescribeInstanceEventNotificationAttributes mocks base method +func (m *MockEC2API) DescribeInstanceEventNotificationAttributes(arg0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributes", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstanceEventNotificationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceEventNotificationAttributes indicates an expected call of DescribeInstanceEventNotificationAttributes +func (mr *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributes), arg0) +} + +// DescribeInstanceEventNotificationAttributesRequest mocks base method +func (m *MockEC2API) DescribeInstanceEventNotificationAttributesRequest(arg0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DescribeInstanceEventNotificationAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeInstanceEventNotificationAttributesOutput) + return ret0, ret1 +} + +// DescribeInstanceEventNotificationAttributesRequest indicates an expected call of DescribeInstanceEventNotificationAttributesRequest +func (mr *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributesRequest), arg0) +} + +// DescribeInstanceEventNotificationAttributesWithContext mocks base method +func (m *MockEC2API) DescribeInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeInstanceEventNotificationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceEventNotificationAttributesWithContext indicates an expected call of DescribeInstanceEventNotificationAttributesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributesWithContext), varargs...) +} + +// DescribeInstanceStatus mocks base method +func (m *MockEC2API) DescribeInstanceStatus(arg0 *ec2.DescribeInstanceStatusInput) (*ec2.DescribeInstanceStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceStatus", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceStatus indicates an expected call of DescribeInstanceStatus +func (mr *MockEC2APIMockRecorder) DescribeInstanceStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatus), arg0) +} + +// DescribeInstanceStatusPages mocks base method +func (m *MockEC2API) DescribeInstanceStatusPages(arg0 *ec2.DescribeInstanceStatusInput, arg1 func(*ec2.DescribeInstanceStatusOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceStatusPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceStatusPages indicates an expected call of DescribeInstanceStatusPages +func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusPages), arg0, arg1) +} + +// DescribeInstanceStatusPagesWithContext mocks base method +func (m *MockEC2API) DescribeInstanceStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 func(*ec2.DescribeInstanceStatusOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceStatusPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceStatusPagesWithContext indicates an expected call of DescribeInstanceStatusPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusPagesWithContext), varargs...) +} + +// DescribeInstanceStatusRequest mocks base method +func (m *MockEC2API) DescribeInstanceStatusRequest(arg0 *ec2.DescribeInstanceStatusInput) (*request.Request, *ec2.DescribeInstanceStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeInstanceStatusOutput) + return ret0, ret1 +} + +// DescribeInstanceStatusRequest indicates an expected call of DescribeInstanceStatusRequest +func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusRequest), arg0) +} + +// DescribeInstanceStatusWithContext mocks base method +func (m *MockEC2API) DescribeInstanceStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.Option) (*ec2.DescribeInstanceStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceStatusWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceStatusWithContext indicates an expected call of DescribeInstanceStatusWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusWithContext), varargs...) +} + +// DescribeInstanceTypeOfferings mocks base method +func (m *MockEC2API) DescribeInstanceTypeOfferings(arg0 *ec2.DescribeInstanceTypeOfferingsInput) (*ec2.DescribeInstanceTypeOfferingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferings", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstanceTypeOfferingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceTypeOfferings indicates an expected call of DescribeInstanceTypeOfferings +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferings), arg0) +} + +// DescribeInstanceTypeOfferingsPages mocks base method +func (m *MockEC2API) DescribeInstanceTypeOfferingsPages(arg0 *ec2.DescribeInstanceTypeOfferingsInput, arg1 func(*ec2.DescribeInstanceTypeOfferingsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceTypeOfferingsPages indicates an expected call of DescribeInstanceTypeOfferingsPages +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsPages), arg0, arg1) +} + +// DescribeInstanceTypeOfferingsPagesWithContext mocks base method +func (m *MockEC2API) DescribeInstanceTypeOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypeOfferingsInput, arg2 func(*ec2.DescribeInstanceTypeOfferingsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceTypeOfferingsPagesWithContext indicates an expected call of DescribeInstanceTypeOfferingsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsPagesWithContext), varargs...) +} + +// DescribeInstanceTypeOfferingsRequest mocks base method +func (m *MockEC2API) DescribeInstanceTypeOfferingsRequest(arg0 *ec2.DescribeInstanceTypeOfferingsInput) (*request.Request, *ec2.DescribeInstanceTypeOfferingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeInstanceTypeOfferingsOutput) + return ret0, ret1 +} + +// DescribeInstanceTypeOfferingsRequest indicates an expected call of DescribeInstanceTypeOfferingsRequest +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsRequest), arg0) +} + +// DescribeInstanceTypeOfferingsWithContext mocks base method +func (m *MockEC2API) DescribeInstanceTypeOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypeOfferingsInput, arg2 ...request.Option) (*ec2.DescribeInstanceTypeOfferingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeInstanceTypeOfferingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceTypeOfferingsWithContext indicates an expected call of DescribeInstanceTypeOfferingsWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsWithContext), varargs...) +} + +// DescribeInstanceTypes mocks base method +func (m *MockEC2API) DescribeInstanceTypes(arg0 *ec2.DescribeInstanceTypesInput) (*ec2.DescribeInstanceTypesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceTypes", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceTypes indicates an expected call of DescribeInstanceTypes +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypes), arg0) +} + +// DescribeInstanceTypesPages mocks base method +func (m *MockEC2API) DescribeInstanceTypesPages(arg0 *ec2.DescribeInstanceTypesInput, arg1 func(*ec2.DescribeInstanceTypesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceTypesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceTypesPages indicates an expected call of DescribeInstanceTypesPages +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesPages), arg0, arg1) +} + +// DescribeInstanceTypesPagesWithContext mocks base method +func (m *MockEC2API) DescribeInstanceTypesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 func(*ec2.DescribeInstanceTypesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceTypesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceTypesPagesWithContext indicates an expected call of DescribeInstanceTypesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesPagesWithContext), varargs...) +} + +// DescribeInstanceTypesRequest mocks base method +func (m *MockEC2API) DescribeInstanceTypesRequest(arg0 *ec2.DescribeInstanceTypesInput) (*request.Request, *ec2.DescribeInstanceTypesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceTypesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeInstanceTypesOutput) + return ret0, ret1 +} + +// DescribeInstanceTypesRequest indicates an expected call of DescribeInstanceTypesRequest +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesRequest), arg0) +} + +// DescribeInstanceTypesWithContext mocks base method +func (m *MockEC2API) DescribeInstanceTypesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 ...request.Option) (*ec2.DescribeInstanceTypesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceTypesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceTypesWithContext indicates an expected call of DescribeInstanceTypesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstanceTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesWithContext), varargs...) +} + +// DescribeInstances mocks base method +func (m *MockEC2API) DescribeInstances(arg0 *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstances", arg0) + ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstances indicates an expected call of DescribeInstances +func (mr *MockEC2APIMockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeInstances), arg0) +} + +// DescribeInstancesPages mocks base method +func (m *MockEC2API) DescribeInstancesPages(arg0 *ec2.DescribeInstancesInput, arg1 func(*ec2.DescribeInstancesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstancesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstancesPages indicates an expected call of DescribeInstancesPages +func (mr *MockEC2APIMockRecorder) DescribeInstancesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesPages), arg0, arg1) +} + +// DescribeInstancesPagesWithContext mocks base method +func (m *MockEC2API) DescribeInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 func(*ec2.DescribeInstancesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstancesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstancesPagesWithContext indicates an expected call of DescribeInstancesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesPagesWithContext), varargs...) +} + +// DescribeInstancesRequest mocks base method +func (m *MockEC2API) DescribeInstancesRequest(arg0 *ec2.DescribeInstancesInput) (*request.Request, *ec2.DescribeInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeInstancesOutput) + return ret0, ret1 +} + +// DescribeInstancesRequest indicates an expected call of DescribeInstancesRequest +func (mr *MockEC2APIMockRecorder) DescribeInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesRequest), arg0) +} + +// DescribeInstancesWithContext mocks base method +func (m *MockEC2API) DescribeInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.Option) (*ec2.DescribeInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstancesWithContext indicates an expected call of DescribeInstancesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesWithContext), varargs...) +} + +// DescribeInternetGateways mocks base method +func (m *MockEC2API) DescribeInternetGateways(arg0 *ec2.DescribeInternetGatewaysInput) (*ec2.DescribeInternetGatewaysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInternetGateways", arg0) + ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInternetGateways indicates an expected call of DescribeInternetGateways +func (mr *MockEC2APIMockRecorder) DescribeInternetGateways(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGateways), arg0) +} + +// DescribeInternetGatewaysPages mocks base method +func (m *MockEC2API) DescribeInternetGatewaysPages(arg0 *ec2.DescribeInternetGatewaysInput, arg1 func(*ec2.DescribeInternetGatewaysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInternetGatewaysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInternetGatewaysPages indicates an expected call of DescribeInternetGatewaysPages +func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysPages), arg0, arg1) +} + +// DescribeInternetGatewaysPagesWithContext mocks base method +func (m *MockEC2API) DescribeInternetGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 func(*ec2.DescribeInternetGatewaysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInternetGatewaysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInternetGatewaysPagesWithContext indicates an expected call of DescribeInternetGatewaysPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysPagesWithContext), varargs...) +} + +// DescribeInternetGatewaysRequest mocks base method +func (m *MockEC2API) DescribeInternetGatewaysRequest(arg0 *ec2.DescribeInternetGatewaysInput) (*request.Request, *ec2.DescribeInternetGatewaysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInternetGatewaysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeInternetGatewaysOutput) + return ret0, ret1 +} + +// DescribeInternetGatewaysRequest indicates an expected call of DescribeInternetGatewaysRequest +func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysRequest), arg0) +} + +// DescribeInternetGatewaysWithContext mocks base method +func (m *MockEC2API) DescribeInternetGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeInternetGatewaysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInternetGatewaysWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInternetGatewaysWithContext indicates an expected call of DescribeInternetGatewaysWithContext +func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysWithContext), varargs...) +} + +// DescribeIpv6Pools mocks base method +func (m *MockEC2API) DescribeIpv6Pools(arg0 *ec2.DescribeIpv6PoolsInput) (*ec2.DescribeIpv6PoolsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIpv6Pools", arg0) + ret0, _ := ret[0].(*ec2.DescribeIpv6PoolsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIpv6Pools indicates an expected call of DescribeIpv6Pools +func (mr *MockEC2APIMockRecorder) DescribeIpv6Pools(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6Pools", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6Pools), arg0) +} + +// DescribeIpv6PoolsPages mocks base method +func (m *MockEC2API) DescribeIpv6PoolsPages(arg0 *ec2.DescribeIpv6PoolsInput, arg1 func(*ec2.DescribeIpv6PoolsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIpv6PoolsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeIpv6PoolsPages indicates an expected call of DescribeIpv6PoolsPages +func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsPages), arg0, arg1) +} + +// DescribeIpv6PoolsPagesWithContext mocks base method +func (m *MockEC2API) DescribeIpv6PoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpv6PoolsInput, arg2 func(*ec2.DescribeIpv6PoolsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeIpv6PoolsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeIpv6PoolsPagesWithContext indicates an expected call of DescribeIpv6PoolsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsPagesWithContext), varargs...) +} + +// DescribeIpv6PoolsRequest mocks base method +func (m *MockEC2API) DescribeIpv6PoolsRequest(arg0 *ec2.DescribeIpv6PoolsInput) (*request.Request, *ec2.DescribeIpv6PoolsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeIpv6PoolsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeIpv6PoolsOutput) + return ret0, ret1 +} + +// DescribeIpv6PoolsRequest indicates an expected call of DescribeIpv6PoolsRequest +func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsRequest), arg0) +} + +// DescribeIpv6PoolsWithContext mocks base method +func (m *MockEC2API) DescribeIpv6PoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpv6PoolsInput, arg2 ...request.Option) (*ec2.DescribeIpv6PoolsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeIpv6PoolsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeIpv6PoolsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeIpv6PoolsWithContext indicates an expected call of DescribeIpv6PoolsWithContext +func (mr *MockEC2APIMockRecorder) DescribeIpv6PoolsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsWithContext), varargs...) +} + +// DescribeKeyPairs mocks base method +func (m *MockEC2API) DescribeKeyPairs(arg0 *ec2.DescribeKeyPairsInput) (*ec2.DescribeKeyPairsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeKeyPairs", arg0) + ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeKeyPairs indicates an expected call of DescribeKeyPairs +func (mr *MockEC2APIMockRecorder) DescribeKeyPairs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairs", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairs), arg0) +} + +// DescribeKeyPairsRequest mocks base method +func (m *MockEC2API) DescribeKeyPairsRequest(arg0 *ec2.DescribeKeyPairsInput) (*request.Request, *ec2.DescribeKeyPairsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeKeyPairsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeKeyPairsOutput) + return ret0, ret1 +} + +// DescribeKeyPairsRequest indicates an expected call of DescribeKeyPairsRequest +func (mr *MockEC2APIMockRecorder) DescribeKeyPairsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairsRequest), arg0) +} + +// DescribeKeyPairsWithContext mocks base method +func (m *MockEC2API) DescribeKeyPairsWithContext(arg0 context.Context, arg1 *ec2.DescribeKeyPairsInput, arg2 ...request.Option) (*ec2.DescribeKeyPairsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeKeyPairsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeKeyPairsWithContext indicates an expected call of DescribeKeyPairsWithContext +func (mr *MockEC2APIMockRecorder) DescribeKeyPairsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairsWithContext), varargs...) +} + +// DescribeLaunchTemplateVersions mocks base method +func (m *MockEC2API) DescribeLaunchTemplateVersions(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*ec2.DescribeLaunchTemplateVersionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersions", arg0) + ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLaunchTemplateVersions indicates an expected call of DescribeLaunchTemplateVersions +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersions), arg0) +} + +// DescribeLaunchTemplateVersionsPages mocks base method +func (m *MockEC2API) DescribeLaunchTemplateVersionsPages(arg0 *ec2.DescribeLaunchTemplateVersionsInput, arg1 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLaunchTemplateVersionsPages indicates an expected call of DescribeLaunchTemplateVersionsPages +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPages), arg0, arg1) +} + +// DescribeLaunchTemplateVersionsPagesWithContext mocks base method +func (m *MockEC2API) DescribeLaunchTemplateVersionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLaunchTemplateVersionsPagesWithContext indicates an expected call of DescribeLaunchTemplateVersionsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPagesWithContext), varargs...) +} + +// DescribeLaunchTemplateVersionsRequest mocks base method +func (m *MockEC2API) DescribeLaunchTemplateVersionsRequest(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*request.Request, *ec2.DescribeLaunchTemplateVersionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeLaunchTemplateVersionsOutput) + return ret0, ret1 +} + +// DescribeLaunchTemplateVersionsRequest indicates an expected call of DescribeLaunchTemplateVersionsRequest +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsRequest), arg0) +} + +// DescribeLaunchTemplateVersionsWithContext mocks base method +func (m *MockEC2API) DescribeLaunchTemplateVersionsWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplateVersionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLaunchTemplateVersionsWithContext indicates an expected call of DescribeLaunchTemplateVersionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsWithContext), varargs...) +} + +// DescribeLaunchTemplates mocks base method +func (m *MockEC2API) DescribeLaunchTemplates(arg0 *ec2.DescribeLaunchTemplatesInput) (*ec2.DescribeLaunchTemplatesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchTemplates", arg0) + ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLaunchTemplates indicates an expected call of DescribeLaunchTemplates +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplates(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplates", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplates), arg0) +} + +// DescribeLaunchTemplatesPages mocks base method +func (m *MockEC2API) DescribeLaunchTemplatesPages(arg0 *ec2.DescribeLaunchTemplatesInput, arg1 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchTemplatesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLaunchTemplatesPages indicates an expected call of DescribeLaunchTemplatesPages +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesPages), arg0, arg1) +} + +// DescribeLaunchTemplatesPagesWithContext mocks base method +func (m *MockEC2API) DescribeLaunchTemplatesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLaunchTemplatesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLaunchTemplatesPagesWithContext indicates an expected call of DescribeLaunchTemplatesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesPagesWithContext), varargs...) +} + +// DescribeLaunchTemplatesRequest mocks base method +func (m *MockEC2API) DescribeLaunchTemplatesRequest(arg0 *ec2.DescribeLaunchTemplatesInput) (*request.Request, *ec2.DescribeLaunchTemplatesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchTemplatesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeLaunchTemplatesOutput) + return ret0, ret1 +} + +// DescribeLaunchTemplatesRequest indicates an expected call of DescribeLaunchTemplatesRequest +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesRequest), arg0) +} + +// DescribeLaunchTemplatesWithContext mocks base method +func (m *MockEC2API) DescribeLaunchTemplatesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplatesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLaunchTemplatesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLaunchTemplatesWithContext indicates an expected call of DescribeLaunchTemplatesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesWithContext), varargs...) +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", arg0) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations), arg0) +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg1 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages), arg0, arg1) +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg2 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext), varargs...) +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest), arg0) +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext), varargs...) +} + +// DescribeLocalGatewayRouteTableVpcAssociations mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociations(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociations", arg0) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTableVpcAssociations indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociations +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociations), arg0) +} + +// DescribeLocalGatewayRouteTableVpcAssociationsPages mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg1 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayRouteTableVpcAssociationsPages indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsPages +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPages), arg0, arg1) +} + +// DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg2 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext), varargs...) +} + +// DescribeLocalGatewayRouteTableVpcAssociationsRequest mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTableVpcAssociationsRequest indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsRequest +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsRequest), arg0) +} + +// DescribeLocalGatewayRouteTableVpcAssociationsWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTableVpcAssociationsWithContext indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsWithContext), varargs...) +} + +// DescribeLocalGatewayRouteTables mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTables(arg0 *ec2.DescribeLocalGatewayRouteTablesInput) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTables", arg0) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTablesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTables indicates an expected call of DescribeLocalGatewayRouteTables +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTables(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTables), arg0) +} + +// DescribeLocalGatewayRouteTablesPages mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTablesPages(arg0 *ec2.DescribeLocalGatewayRouteTablesInput, arg1 func(*ec2.DescribeLocalGatewayRouteTablesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayRouteTablesPages indicates an expected call of DescribeLocalGatewayRouteTablesPages +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesPages), arg0, arg1) +} + +// DescribeLocalGatewayRouteTablesPagesWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTablesInput, arg2 func(*ec2.DescribeLocalGatewayRouteTablesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayRouteTablesPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTablesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesPagesWithContext), varargs...) +} + +// DescribeLocalGatewayRouteTablesRequest mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTablesRequest(arg0 *ec2.DescribeLocalGatewayRouteTablesInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTablesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTablesOutput) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTablesRequest indicates an expected call of DescribeLocalGatewayRouteTablesRequest +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesRequest), arg0) +} + +// DescribeLocalGatewayRouteTablesWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTablesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayRouteTablesWithContext indicates an expected call of DescribeLocalGatewayRouteTablesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesWithContext), varargs...) +} + +// DescribeLocalGatewayVirtualInterfaceGroups mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroups(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroups", arg0) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayVirtualInterfaceGroups indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroups +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroups), arg0) +} + +// DescribeLocalGatewayVirtualInterfaceGroupsPages mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg1 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayVirtualInterfaceGroupsPages indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsPages +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPages), arg0, arg1) +} + +// DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg2 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext), varargs...) +} + +// DescribeLocalGatewayVirtualInterfaceGroupsRequest mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) + return ret0, ret1 +} + +// DescribeLocalGatewayVirtualInterfaceGroupsRequest indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsRequest +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsRequest), arg0) +} + +// DescribeLocalGatewayVirtualInterfaceGroupsWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayVirtualInterfaceGroupsWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsWithContext), varargs...) +} + +// DescribeLocalGatewayVirtualInterfaces mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaces(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaces", arg0) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayVirtualInterfaces indicates an expected call of DescribeLocalGatewayVirtualInterfaces +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaces(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaces), arg0) +} + +// DescribeLocalGatewayVirtualInterfacesPages mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesPages(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg1 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayVirtualInterfacesPages indicates an expected call of DescribeLocalGatewayVirtualInterfacesPages +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesPages), arg0, arg1) +} + +// DescribeLocalGatewayVirtualInterfacesPagesWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg2 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewayVirtualInterfacesPagesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfacesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesPagesWithContext), varargs...) +} + +// DescribeLocalGatewayVirtualInterfacesRequest mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesRequest(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfacesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput) + return ret0, ret1 +} + +// DescribeLocalGatewayVirtualInterfacesRequest indicates an expected call of DescribeLocalGatewayVirtualInterfacesRequest +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesRequest), arg0) +} + +// DescribeLocalGatewayVirtualInterfacesWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewayVirtualInterfacesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfacesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesWithContext), varargs...) +} + +// DescribeLocalGateways mocks base method +func (m *MockEC2API) DescribeLocalGateways(arg0 *ec2.DescribeLocalGatewaysInput) (*ec2.DescribeLocalGatewaysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGateways", arg0) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGateways indicates an expected call of DescribeLocalGateways +func (mr *MockEC2APIMockRecorder) DescribeLocalGateways(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGateways), arg0) +} + +// DescribeLocalGatewaysPages mocks base method +func (m *MockEC2API) DescribeLocalGatewaysPages(arg0 *ec2.DescribeLocalGatewaysInput, arg1 func(*ec2.DescribeLocalGatewaysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewaysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewaysPages indicates an expected call of DescribeLocalGatewaysPages +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysPages), arg0, arg1) +} + +// DescribeLocalGatewaysPagesWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewaysInput, arg2 func(*ec2.DescribeLocalGatewaysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewaysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLocalGatewaysPagesWithContext indicates an expected call of DescribeLocalGatewaysPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysPagesWithContext), varargs...) +} + +// DescribeLocalGatewaysRequest mocks base method +func (m *MockEC2API) DescribeLocalGatewaysRequest(arg0 *ec2.DescribeLocalGatewaysInput) (*request.Request, *ec2.DescribeLocalGatewaysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLocalGatewaysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeLocalGatewaysOutput) + return ret0, ret1 +} + +// DescribeLocalGatewaysRequest indicates an expected call of DescribeLocalGatewaysRequest +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysRequest), arg0) +} + +// DescribeLocalGatewaysWithContext mocks base method +func (m *MockEC2API) DescribeLocalGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewaysInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewaysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLocalGatewaysWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeLocalGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLocalGatewaysWithContext indicates an expected call of DescribeLocalGatewaysWithContext +func (mr *MockEC2APIMockRecorder) DescribeLocalGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysWithContext), varargs...) +} + +// DescribeManagedPrefixLists mocks base method +func (m *MockEC2API) DescribeManagedPrefixLists(arg0 *ec2.DescribeManagedPrefixListsInput) (*ec2.DescribeManagedPrefixListsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeManagedPrefixLists", arg0) + ret0, _ := ret[0].(*ec2.DescribeManagedPrefixListsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeManagedPrefixLists indicates an expected call of DescribeManagedPrefixLists +func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixLists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixLists", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixLists), arg0) +} + +// DescribeManagedPrefixListsPages mocks base method +func (m *MockEC2API) DescribeManagedPrefixListsPages(arg0 *ec2.DescribeManagedPrefixListsInput, arg1 func(*ec2.DescribeManagedPrefixListsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeManagedPrefixListsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeManagedPrefixListsPages indicates an expected call of DescribeManagedPrefixListsPages +func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsPages), arg0, arg1) +} + +// DescribeManagedPrefixListsPagesWithContext mocks base method +func (m *MockEC2API) DescribeManagedPrefixListsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeManagedPrefixListsInput, arg2 func(*ec2.DescribeManagedPrefixListsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeManagedPrefixListsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeManagedPrefixListsPagesWithContext indicates an expected call of DescribeManagedPrefixListsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsPagesWithContext), varargs...) +} + +// DescribeManagedPrefixListsRequest mocks base method +func (m *MockEC2API) DescribeManagedPrefixListsRequest(arg0 *ec2.DescribeManagedPrefixListsInput) (*request.Request, *ec2.DescribeManagedPrefixListsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeManagedPrefixListsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeManagedPrefixListsOutput) + return ret0, ret1 +} + +// DescribeManagedPrefixListsRequest indicates an expected call of DescribeManagedPrefixListsRequest +func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsRequest), arg0) +} + +// DescribeManagedPrefixListsWithContext mocks base method +func (m *MockEC2API) DescribeManagedPrefixListsWithContext(arg0 context.Context, arg1 *ec2.DescribeManagedPrefixListsInput, arg2 ...request.Option) (*ec2.DescribeManagedPrefixListsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeManagedPrefixListsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeManagedPrefixListsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeManagedPrefixListsWithContext indicates an expected call of DescribeManagedPrefixListsWithContext +func (mr *MockEC2APIMockRecorder) DescribeManagedPrefixListsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeManagedPrefixListsWithContext), varargs...) +} + +// DescribeMovingAddresses mocks base method +func (m *MockEC2API) DescribeMovingAddresses(arg0 *ec2.DescribeMovingAddressesInput) (*ec2.DescribeMovingAddressesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMovingAddresses", arg0) + ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMovingAddresses indicates an expected call of DescribeMovingAddresses +func (mr *MockEC2APIMockRecorder) DescribeMovingAddresses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddresses), arg0) +} + +// DescribeMovingAddressesPages mocks base method +func (m *MockEC2API) DescribeMovingAddressesPages(arg0 *ec2.DescribeMovingAddressesInput, arg1 func(*ec2.DescribeMovingAddressesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMovingAddressesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeMovingAddressesPages indicates an expected call of DescribeMovingAddressesPages +func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesPages), arg0, arg1) +} + +// DescribeMovingAddressesPagesWithContext mocks base method +func (m *MockEC2API) DescribeMovingAddressesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 func(*ec2.DescribeMovingAddressesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeMovingAddressesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeMovingAddressesPagesWithContext indicates an expected call of DescribeMovingAddressesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesPagesWithContext), varargs...) +} + +// DescribeMovingAddressesRequest mocks base method +func (m *MockEC2API) DescribeMovingAddressesRequest(arg0 *ec2.DescribeMovingAddressesInput) (*request.Request, *ec2.DescribeMovingAddressesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMovingAddressesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeMovingAddressesOutput) + return ret0, ret1 +} + +// DescribeMovingAddressesRequest indicates an expected call of DescribeMovingAddressesRequest +func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesRequest), arg0) +} + +// DescribeMovingAddressesWithContext mocks base method +func (m *MockEC2API) DescribeMovingAddressesWithContext(arg0 context.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 ...request.Option) (*ec2.DescribeMovingAddressesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeMovingAddressesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMovingAddressesWithContext indicates an expected call of DescribeMovingAddressesWithContext +func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesWithContext), varargs...) +} + +// DescribeNatGateways mocks base method +func (m *MockEC2API) DescribeNatGateways(arg0 *ec2.DescribeNatGatewaysInput) (*ec2.DescribeNatGatewaysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNatGateways", arg0) + ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNatGateways indicates an expected call of DescribeNatGateways +func (mr *MockEC2APIMockRecorder) DescribeNatGateways(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGateways), arg0) +} + +// DescribeNatGatewaysPages mocks base method +func (m *MockEC2API) DescribeNatGatewaysPages(arg0 *ec2.DescribeNatGatewaysInput, arg1 func(*ec2.DescribeNatGatewaysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNatGatewaysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNatGatewaysPages indicates an expected call of DescribeNatGatewaysPages +func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysPages), arg0, arg1) +} + +// DescribeNatGatewaysPagesWithContext mocks base method +func (m *MockEC2API) DescribeNatGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 func(*ec2.DescribeNatGatewaysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNatGatewaysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNatGatewaysPagesWithContext indicates an expected call of DescribeNatGatewaysPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysPagesWithContext), varargs...) +} + +// DescribeNatGatewaysRequest mocks base method +func (m *MockEC2API) DescribeNatGatewaysRequest(arg0 *ec2.DescribeNatGatewaysInput) (*request.Request, *ec2.DescribeNatGatewaysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNatGatewaysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeNatGatewaysOutput) + return ret0, ret1 +} + +// DescribeNatGatewaysRequest indicates an expected call of DescribeNatGatewaysRequest +func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysRequest), arg0) +} + +// DescribeNatGatewaysWithContext mocks base method +func (m *MockEC2API) DescribeNatGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.Option) (*ec2.DescribeNatGatewaysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNatGatewaysWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNatGatewaysWithContext indicates an expected call of DescribeNatGatewaysWithContext +func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysWithContext), varargs...) +} + +// DescribeNetworkAcls mocks base method +func (m *MockEC2API) DescribeNetworkAcls(arg0 *ec2.DescribeNetworkAclsInput) (*ec2.DescribeNetworkAclsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkAcls", arg0) + ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkAcls indicates an expected call of DescribeNetworkAcls +func (mr *MockEC2APIMockRecorder) DescribeNetworkAcls(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAcls", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAcls), arg0) +} + +// DescribeNetworkAclsPages mocks base method +func (m *MockEC2API) DescribeNetworkAclsPages(arg0 *ec2.DescribeNetworkAclsInput, arg1 func(*ec2.DescribeNetworkAclsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkAclsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkAclsPages indicates an expected call of DescribeNetworkAclsPages +func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsPages), arg0, arg1) +} + +// DescribeNetworkAclsPagesWithContext mocks base method +func (m *MockEC2API) DescribeNetworkAclsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 func(*ec2.DescribeNetworkAclsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkAclsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkAclsPagesWithContext indicates an expected call of DescribeNetworkAclsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsPagesWithContext), varargs...) +} + +// DescribeNetworkAclsRequest mocks base method +func (m *MockEC2API) DescribeNetworkAclsRequest(arg0 *ec2.DescribeNetworkAclsInput) (*request.Request, *ec2.DescribeNetworkAclsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkAclsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeNetworkAclsOutput) + return ret0, ret1 +} + +// DescribeNetworkAclsRequest indicates an expected call of DescribeNetworkAclsRequest +func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsRequest), arg0) +} + +// DescribeNetworkAclsWithContext mocks base method +func (m *MockEC2API) DescribeNetworkAclsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 ...request.Option) (*ec2.DescribeNetworkAclsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkAclsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkAclsWithContext indicates an expected call of DescribeNetworkAclsWithContext +func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsWithContext), varargs...) +} + +// DescribeNetworkInterfaceAttribute mocks base method +func (m *MockEC2API) DescribeNetworkInterfaceAttribute(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttribute", arg0) + ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInterfaceAttribute indicates an expected call of DescribeNetworkInterfaceAttribute +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttribute), arg0) +} + +// DescribeNetworkInterfaceAttributeRequest mocks base method +func (m *MockEC2API) DescribeNetworkInterfaceAttributeRequest(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*request.Request, *ec2.DescribeNetworkInterfaceAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeNetworkInterfaceAttributeOutput) + return ret0, ret1 +} + +// DescribeNetworkInterfaceAttributeRequest indicates an expected call of DescribeNetworkInterfaceAttributeRequest +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeRequest), arg0) +} + +// DescribeNetworkInterfaceAttributeWithContext mocks base method +func (m *MockEC2API) DescribeNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInterfaceAttributeWithContext indicates an expected call of DescribeNetworkInterfaceAttributeWithContext +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeWithContext), varargs...) +} + +// DescribeNetworkInterfacePermissions mocks base method +func (m *MockEC2API) DescribeNetworkInterfacePermissions(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissions", arg0) + ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInterfacePermissions indicates an expected call of DescribeNetworkInterfacePermissions +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissions), arg0) +} + +// DescribeNetworkInterfacePermissionsPages mocks base method +func (m *MockEC2API) DescribeNetworkInterfacePermissionsPages(arg0 *ec2.DescribeNetworkInterfacePermissionsInput, arg1 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkInterfacePermissionsPages indicates an expected call of DescribeNetworkInterfacePermissionsPages +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPages), arg0, arg1) +} + +// DescribeNetworkInterfacePermissionsPagesWithContext mocks base method +func (m *MockEC2API) DescribeNetworkInterfacePermissionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkInterfacePermissionsPagesWithContext indicates an expected call of DescribeNetworkInterfacePermissionsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPagesWithContext), varargs...) +} + +// DescribeNetworkInterfacePermissionsRequest mocks base method +func (m *MockEC2API) DescribeNetworkInterfacePermissionsRequest(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*request.Request, *ec2.DescribeNetworkInterfacePermissionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacePermissionsOutput) + return ret0, ret1 +} + +// DescribeNetworkInterfacePermissionsRequest indicates an expected call of DescribeNetworkInterfacePermissionsRequest +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsRequest), arg0) +} + +// DescribeNetworkInterfacePermissionsWithContext mocks base method +func (m *MockEC2API) DescribeNetworkInterfacePermissionsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInterfacePermissionsWithContext indicates an expected call of DescribeNetworkInterfacePermissionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsWithContext), varargs...) +} + +// DescribeNetworkInterfaces mocks base method +func (m *MockEC2API) DescribeNetworkInterfaces(arg0 *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInterfaces", arg0) + ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInterfaces indicates an expected call of DescribeNetworkInterfaces +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaces(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaces), arg0) +} + +// DescribeNetworkInterfacesPages mocks base method +func (m *MockEC2API) DescribeNetworkInterfacesPages(arg0 *ec2.DescribeNetworkInterfacesInput, arg1 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkInterfacesPages indicates an expected call of DescribeNetworkInterfacesPages +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesPages), arg0, arg1) +} + +// DescribeNetworkInterfacesPagesWithContext mocks base method +func (m *MockEC2API) DescribeNetworkInterfacesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNetworkInterfacesPagesWithContext indicates an expected call of DescribeNetworkInterfacesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesPagesWithContext), varargs...) +} + +// DescribeNetworkInterfacesRequest mocks base method +func (m *MockEC2API) DescribeNetworkInterfacesRequest(arg0 *ec2.DescribeNetworkInterfacesInput) (*request.Request, *ec2.DescribeNetworkInterfacesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNetworkInterfacesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacesOutput) + return ret0, ret1 +} + +// DescribeNetworkInterfacesRequest indicates an expected call of DescribeNetworkInterfacesRequest +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesRequest), arg0) +} + +// DescribeNetworkInterfacesWithContext mocks base method +func (m *MockEC2API) DescribeNetworkInterfacesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNetworkInterfacesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNetworkInterfacesWithContext indicates an expected call of DescribeNetworkInterfacesWithContext +func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesWithContext), varargs...) +} + +// DescribePlacementGroups mocks base method +func (m *MockEC2API) DescribePlacementGroups(arg0 *ec2.DescribePlacementGroupsInput) (*ec2.DescribePlacementGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePlacementGroups", arg0) + ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePlacementGroups indicates an expected call of DescribePlacementGroups +func (mr *MockEC2APIMockRecorder) DescribePlacementGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroups", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroups), arg0) +} + +// DescribePlacementGroupsRequest mocks base method +func (m *MockEC2API) DescribePlacementGroupsRequest(arg0 *ec2.DescribePlacementGroupsInput) (*request.Request, *ec2.DescribePlacementGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePlacementGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribePlacementGroupsOutput) + return ret0, ret1 +} + +// DescribePlacementGroupsRequest indicates an expected call of DescribePlacementGroupsRequest +func (mr *MockEC2APIMockRecorder) DescribePlacementGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroupsRequest), arg0) +} + +// DescribePlacementGroupsWithContext mocks base method +func (m *MockEC2API) DescribePlacementGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribePlacementGroupsInput, arg2 ...request.Option) (*ec2.DescribePlacementGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePlacementGroupsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePlacementGroupsWithContext indicates an expected call of DescribePlacementGroupsWithContext +func (mr *MockEC2APIMockRecorder) DescribePlacementGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroupsWithContext), varargs...) +} + +// DescribePrefixLists mocks base method +func (m *MockEC2API) DescribePrefixLists(arg0 *ec2.DescribePrefixListsInput) (*ec2.DescribePrefixListsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePrefixLists", arg0) + ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePrefixLists indicates an expected call of DescribePrefixLists +func (mr *MockEC2APIMockRecorder) DescribePrefixLists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixLists", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixLists), arg0) +} + +// DescribePrefixListsPages mocks base method +func (m *MockEC2API) DescribePrefixListsPages(arg0 *ec2.DescribePrefixListsInput, arg1 func(*ec2.DescribePrefixListsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePrefixListsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePrefixListsPages indicates an expected call of DescribePrefixListsPages +func (mr *MockEC2APIMockRecorder) DescribePrefixListsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsPages), arg0, arg1) +} + +// DescribePrefixListsPagesWithContext mocks base method +func (m *MockEC2API) DescribePrefixListsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePrefixListsInput, arg2 func(*ec2.DescribePrefixListsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePrefixListsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePrefixListsPagesWithContext indicates an expected call of DescribePrefixListsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribePrefixListsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsPagesWithContext), varargs...) +} + +// DescribePrefixListsRequest mocks base method +func (m *MockEC2API) DescribePrefixListsRequest(arg0 *ec2.DescribePrefixListsInput) (*request.Request, *ec2.DescribePrefixListsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePrefixListsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribePrefixListsOutput) + return ret0, ret1 +} + +// DescribePrefixListsRequest indicates an expected call of DescribePrefixListsRequest +func (mr *MockEC2APIMockRecorder) DescribePrefixListsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsRequest), arg0) +} + +// DescribePrefixListsWithContext mocks base method +func (m *MockEC2API) DescribePrefixListsWithContext(arg0 context.Context, arg1 *ec2.DescribePrefixListsInput, arg2 ...request.Option) (*ec2.DescribePrefixListsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePrefixListsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePrefixListsWithContext indicates an expected call of DescribePrefixListsWithContext +func (mr *MockEC2APIMockRecorder) DescribePrefixListsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsWithContext), varargs...) +} + +// DescribePrincipalIdFormat mocks base method +func (m *MockEC2API) DescribePrincipalIdFormat(arg0 *ec2.DescribePrincipalIdFormatInput) (*ec2.DescribePrincipalIdFormatOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePrincipalIdFormat", arg0) + ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePrincipalIdFormat indicates an expected call of DescribePrincipalIdFormat +func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormat), arg0) +} + +// DescribePrincipalIdFormatPages mocks base method +func (m *MockEC2API) DescribePrincipalIdFormatPages(arg0 *ec2.DescribePrincipalIdFormatInput, arg1 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePrincipalIdFormatPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePrincipalIdFormatPages indicates an expected call of DescribePrincipalIdFormatPages +func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatPages), arg0, arg1) +} + +// DescribePrincipalIdFormatPagesWithContext mocks base method +func (m *MockEC2API) DescribePrincipalIdFormatPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePrincipalIdFormatPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePrincipalIdFormatPagesWithContext indicates an expected call of DescribePrincipalIdFormatPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatPagesWithContext), varargs...) +} + +// DescribePrincipalIdFormatRequest mocks base method +func (m *MockEC2API) DescribePrincipalIdFormatRequest(arg0 *ec2.DescribePrincipalIdFormatInput) (*request.Request, *ec2.DescribePrincipalIdFormatOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePrincipalIdFormatRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribePrincipalIdFormatOutput) + return ret0, ret1 +} + +// DescribePrincipalIdFormatRequest indicates an expected call of DescribePrincipalIdFormatRequest +func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatRequest), arg0) +} + +// DescribePrincipalIdFormatWithContext mocks base method +func (m *MockEC2API) DescribePrincipalIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 ...request.Option) (*ec2.DescribePrincipalIdFormatOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePrincipalIdFormatWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePrincipalIdFormatWithContext indicates an expected call of DescribePrincipalIdFormatWithContext +func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatWithContext), varargs...) +} + +// DescribePublicIpv4Pools mocks base method +func (m *MockEC2API) DescribePublicIpv4Pools(arg0 *ec2.DescribePublicIpv4PoolsInput) (*ec2.DescribePublicIpv4PoolsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePublicIpv4Pools", arg0) + ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePublicIpv4Pools indicates an expected call of DescribePublicIpv4Pools +func (mr *MockEC2APIMockRecorder) DescribePublicIpv4Pools(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4Pools", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4Pools), arg0) +} + +// DescribePublicIpv4PoolsPages mocks base method +func (m *MockEC2API) DescribePublicIpv4PoolsPages(arg0 *ec2.DescribePublicIpv4PoolsInput, arg1 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePublicIpv4PoolsPages indicates an expected call of DescribePublicIpv4PoolsPages +func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsPages), arg0, arg1) +} + +// DescribePublicIpv4PoolsPagesWithContext mocks base method +func (m *MockEC2API) DescribePublicIpv4PoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePublicIpv4PoolsPagesWithContext indicates an expected call of DescribePublicIpv4PoolsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsPagesWithContext), varargs...) +} + +// DescribePublicIpv4PoolsRequest mocks base method +func (m *MockEC2API) DescribePublicIpv4PoolsRequest(arg0 *ec2.DescribePublicIpv4PoolsInput) (*request.Request, *ec2.DescribePublicIpv4PoolsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribePublicIpv4PoolsOutput) + return ret0, ret1 +} + +// DescribePublicIpv4PoolsRequest indicates an expected call of DescribePublicIpv4PoolsRequest +func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsRequest), arg0) +} + +// DescribePublicIpv4PoolsWithContext mocks base method +func (m *MockEC2API) DescribePublicIpv4PoolsWithContext(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 ...request.Option) (*ec2.DescribePublicIpv4PoolsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePublicIpv4PoolsWithContext indicates an expected call of DescribePublicIpv4PoolsWithContext +func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsWithContext), varargs...) +} + +// DescribeRegions mocks base method +func (m *MockEC2API) DescribeRegions(arg0 *ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegions", arg0) + ret0, _ := ret[0].(*ec2.DescribeRegionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegions indicates an expected call of DescribeRegions +func (mr *MockEC2APIMockRecorder) DescribeRegions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegions", reflect.TypeOf((*MockEC2API)(nil).DescribeRegions), arg0) +} + +// DescribeRegionsRequest mocks base method +func (m *MockEC2API) DescribeRegionsRequest(arg0 *ec2.DescribeRegionsInput) (*request.Request, *ec2.DescribeRegionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRegionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeRegionsOutput) + return ret0, ret1 +} + +// DescribeRegionsRequest indicates an expected call of DescribeRegionsRequest +func (mr *MockEC2APIMockRecorder) DescribeRegionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsRequest), arg0) +} + +// DescribeRegionsWithContext mocks base method +func (m *MockEC2API) DescribeRegionsWithContext(arg0 context.Context, arg1 *ec2.DescribeRegionsInput, arg2 ...request.Option) (*ec2.DescribeRegionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRegionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeRegionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRegionsWithContext indicates an expected call of DescribeRegionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeRegionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsWithContext), varargs...) +} + +// DescribeReservedInstances mocks base method +func (m *MockEC2API) DescribeReservedInstances(arg0 *ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstances", arg0) + ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReservedInstances indicates an expected call of DescribeReservedInstances +func (mr *MockEC2APIMockRecorder) DescribeReservedInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstances), arg0) +} + +// DescribeReservedInstancesListings mocks base method +func (m *MockEC2API) DescribeReservedInstancesListings(arg0 *ec2.DescribeReservedInstancesListingsInput) (*ec2.DescribeReservedInstancesListingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesListings", arg0) + ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReservedInstancesListings indicates an expected call of DescribeReservedInstancesListings +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListings), arg0) +} + +// DescribeReservedInstancesListingsRequest mocks base method +func (m *MockEC2API) DescribeReservedInstancesListingsRequest(arg0 *ec2.DescribeReservedInstancesListingsInput) (*request.Request, *ec2.DescribeReservedInstancesListingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeReservedInstancesListingsOutput) + return ret0, ret1 +} + +// DescribeReservedInstancesListingsRequest indicates an expected call of DescribeReservedInstancesListingsRequest +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListingsRequest), arg0) +} + +// DescribeReservedInstancesListingsWithContext mocks base method +func (m *MockEC2API) DescribeReservedInstancesListingsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesListingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesListingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReservedInstancesListingsWithContext indicates an expected call of DescribeReservedInstancesListingsWithContext +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListingsWithContext), varargs...) +} + +// DescribeReservedInstancesModifications mocks base method +func (m *MockEC2API) DescribeReservedInstancesModifications(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*ec2.DescribeReservedInstancesModificationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesModifications", arg0) + ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReservedInstancesModifications indicates an expected call of DescribeReservedInstancesModifications +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModifications(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModifications), arg0) +} + +// DescribeReservedInstancesModificationsPages mocks base method +func (m *MockEC2API) DescribeReservedInstancesModificationsPages(arg0 *ec2.DescribeReservedInstancesModificationsInput, arg1 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeReservedInstancesModificationsPages indicates an expected call of DescribeReservedInstancesModificationsPages +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsPages), arg0, arg1) +} + +// DescribeReservedInstancesModificationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeReservedInstancesModificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeReservedInstancesModificationsPagesWithContext indicates an expected call of DescribeReservedInstancesModificationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsPagesWithContext), varargs...) +} + +// DescribeReservedInstancesModificationsRequest mocks base method +func (m *MockEC2API) DescribeReservedInstancesModificationsRequest(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*request.Request, *ec2.DescribeReservedInstancesModificationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeReservedInstancesModificationsOutput) + return ret0, ret1 +} + +// DescribeReservedInstancesModificationsRequest indicates an expected call of DescribeReservedInstancesModificationsRequest +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsRequest), arg0) +} + +// DescribeReservedInstancesModificationsWithContext mocks base method +func (m *MockEC2API) DescribeReservedInstancesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesModificationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReservedInstancesModificationsWithContext indicates an expected call of DescribeReservedInstancesModificationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsWithContext), varargs...) +} + +// DescribeReservedInstancesOfferings mocks base method +func (m *MockEC2API) DescribeReservedInstancesOfferings(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*ec2.DescribeReservedInstancesOfferingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferings", arg0) + ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReservedInstancesOfferings indicates an expected call of DescribeReservedInstancesOfferings +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferings), arg0) +} + +// DescribeReservedInstancesOfferingsPages mocks base method +func (m *MockEC2API) DescribeReservedInstancesOfferingsPages(arg0 *ec2.DescribeReservedInstancesOfferingsInput, arg1 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeReservedInstancesOfferingsPages indicates an expected call of DescribeReservedInstancesOfferingsPages +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPages), arg0, arg1) +} + +// DescribeReservedInstancesOfferingsPagesWithContext mocks base method +func (m *MockEC2API) DescribeReservedInstancesOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeReservedInstancesOfferingsPagesWithContext indicates an expected call of DescribeReservedInstancesOfferingsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPagesWithContext), varargs...) +} + +// DescribeReservedInstancesOfferingsRequest mocks base method +func (m *MockEC2API) DescribeReservedInstancesOfferingsRequest(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*request.Request, *ec2.DescribeReservedInstancesOfferingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOfferingsOutput) + return ret0, ret1 +} + +// DescribeReservedInstancesOfferingsRequest indicates an expected call of DescribeReservedInstancesOfferingsRequest +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsRequest), arg0) +} + +// DescribeReservedInstancesOfferingsWithContext mocks base method +func (m *MockEC2API) DescribeReservedInstancesOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOfferingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReservedInstancesOfferingsWithContext indicates an expected call of DescribeReservedInstancesOfferingsWithContext +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsWithContext), varargs...) +} + +// DescribeReservedInstancesRequest mocks base method +func (m *MockEC2API) DescribeReservedInstancesRequest(arg0 *ec2.DescribeReservedInstancesInput) (*request.Request, *ec2.DescribeReservedInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeReservedInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOutput) + return ret0, ret1 +} + +// DescribeReservedInstancesRequest indicates an expected call of DescribeReservedInstancesRequest +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesRequest), arg0) +} + +// DescribeReservedInstancesWithContext mocks base method +func (m *MockEC2API) DescribeReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeReservedInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeReservedInstancesWithContext indicates an expected call of DescribeReservedInstancesWithContext +func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesWithContext), varargs...) +} + +// DescribeRouteTables mocks base method +func (m *MockEC2API) DescribeRouteTables(arg0 *ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRouteTables", arg0) + ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRouteTables indicates an expected call of DescribeRouteTables +func (mr *MockEC2APIMockRecorder) DescribeRouteTables(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTables), arg0) +} + +// DescribeRouteTablesPages mocks base method +func (m *MockEC2API) DescribeRouteTablesPages(arg0 *ec2.DescribeRouteTablesInput, arg1 func(*ec2.DescribeRouteTablesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRouteTablesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRouteTablesPages indicates an expected call of DescribeRouteTablesPages +func (mr *MockEC2APIMockRecorder) DescribeRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesPages), arg0, arg1) +} + +// DescribeRouteTablesPagesWithContext mocks base method +func (m *MockEC2API) DescribeRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 func(*ec2.DescribeRouteTablesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRouteTablesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRouteTablesPagesWithContext indicates an expected call of DescribeRouteTablesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeRouteTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesPagesWithContext), varargs...) +} + +// DescribeRouteTablesRequest mocks base method +func (m *MockEC2API) DescribeRouteTablesRequest(arg0 *ec2.DescribeRouteTablesInput) (*request.Request, *ec2.DescribeRouteTablesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRouteTablesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeRouteTablesOutput) + return ret0, ret1 +} + +// DescribeRouteTablesRequest indicates an expected call of DescribeRouteTablesRequest +func (mr *MockEC2APIMockRecorder) DescribeRouteTablesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesRequest), arg0) +} + +// DescribeRouteTablesWithContext mocks base method +func (m *MockEC2API) DescribeRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeRouteTablesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRouteTablesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRouteTablesWithContext indicates an expected call of DescribeRouteTablesWithContext +func (mr *MockEC2APIMockRecorder) DescribeRouteTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesWithContext), varargs...) +} + +// DescribeScheduledInstanceAvailability mocks base method +func (m *MockEC2API) DescribeScheduledInstanceAvailability(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailability", arg0) + ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScheduledInstanceAvailability indicates an expected call of DescribeScheduledInstanceAvailability +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailability(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailability", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailability), arg0) +} + +// DescribeScheduledInstanceAvailabilityPages mocks base method +func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPages(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput, arg1 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScheduledInstanceAvailabilityPages indicates an expected call of DescribeScheduledInstanceAvailabilityPages +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPages), arg0, arg1) +} + +// DescribeScheduledInstanceAvailabilityPagesWithContext mocks base method +func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScheduledInstanceAvailabilityPagesWithContext indicates an expected call of DescribeScheduledInstanceAvailabilityPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPagesWithContext), varargs...) +} + +// DescribeScheduledInstanceAvailabilityRequest mocks base method +func (m *MockEC2API) DescribeScheduledInstanceAvailabilityRequest(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*request.Request, *ec2.DescribeScheduledInstanceAvailabilityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeScheduledInstanceAvailabilityOutput) + return ret0, ret1 +} + +// DescribeScheduledInstanceAvailabilityRequest indicates an expected call of DescribeScheduledInstanceAvailabilityRequest +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityRequest), arg0) +} + +// DescribeScheduledInstanceAvailabilityWithContext mocks base method +func (m *MockEC2API) DescribeScheduledInstanceAvailabilityWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScheduledInstanceAvailabilityWithContext indicates an expected call of DescribeScheduledInstanceAvailabilityWithContext +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityWithContext), varargs...) +} + +// DescribeScheduledInstances mocks base method +func (m *MockEC2API) DescribeScheduledInstances(arg0 *ec2.DescribeScheduledInstancesInput) (*ec2.DescribeScheduledInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledInstances", arg0) + ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScheduledInstances indicates an expected call of DescribeScheduledInstances +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstances), arg0) +} + +// DescribeScheduledInstancesPages mocks base method +func (m *MockEC2API) DescribeScheduledInstancesPages(arg0 *ec2.DescribeScheduledInstancesInput, arg1 func(*ec2.DescribeScheduledInstancesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledInstancesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScheduledInstancesPages indicates an expected call of DescribeScheduledInstancesPages +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesPages), arg0, arg1) +} + +// DescribeScheduledInstancesPagesWithContext mocks base method +func (m *MockEC2API) DescribeScheduledInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 func(*ec2.DescribeScheduledInstancesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScheduledInstancesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScheduledInstancesPagesWithContext indicates an expected call of DescribeScheduledInstancesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesPagesWithContext), varargs...) +} + +// DescribeScheduledInstancesRequest mocks base method +func (m *MockEC2API) DescribeScheduledInstancesRequest(arg0 *ec2.DescribeScheduledInstancesInput) (*request.Request, *ec2.DescribeScheduledInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeScheduledInstancesOutput) + return ret0, ret1 +} + +// DescribeScheduledInstancesRequest indicates an expected call of DescribeScheduledInstancesRequest +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesRequest), arg0) +} + +// DescribeScheduledInstancesWithContext mocks base method +func (m *MockEC2API) DescribeScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScheduledInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScheduledInstancesWithContext indicates an expected call of DescribeScheduledInstancesWithContext +func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesWithContext), varargs...) +} + +// DescribeSecurityGroupReferences mocks base method +func (m *MockEC2API) DescribeSecurityGroupReferences(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*ec2.DescribeSecurityGroupReferencesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSecurityGroupReferences", arg0) + ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSecurityGroupReferences indicates an expected call of DescribeSecurityGroupReferences +func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferences(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferences", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferences), arg0) +} + +// DescribeSecurityGroupReferencesRequest mocks base method +func (m *MockEC2API) DescribeSecurityGroupReferencesRequest(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*request.Request, *ec2.DescribeSecurityGroupReferencesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSecurityGroupReferencesOutput) + return ret0, ret1 +} + +// DescribeSecurityGroupReferencesRequest indicates an expected call of DescribeSecurityGroupReferencesRequest +func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferencesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferencesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferencesRequest), arg0) +} + +// DescribeSecurityGroupReferencesWithContext mocks base method +func (m *MockEC2API) DescribeSecurityGroupReferencesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupReferencesInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupReferencesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSecurityGroupReferencesWithContext indicates an expected call of DescribeSecurityGroupReferencesWithContext +func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferencesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferencesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferencesWithContext), varargs...) +} + +// DescribeSecurityGroups mocks base method +func (m *MockEC2API) DescribeSecurityGroups(arg0 *ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSecurityGroups", arg0) + ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSecurityGroups indicates an expected call of DescribeSecurityGroups +func (mr *MockEC2APIMockRecorder) DescribeSecurityGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroups), arg0) +} + +// DescribeSecurityGroupsPages mocks base method +func (m *MockEC2API) DescribeSecurityGroupsPages(arg0 *ec2.DescribeSecurityGroupsInput, arg1 func(*ec2.DescribeSecurityGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSecurityGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSecurityGroupsPages indicates an expected call of DescribeSecurityGroupsPages +func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsPages), arg0, arg1) +} + +// DescribeSecurityGroupsPagesWithContext mocks base method +func (m *MockEC2API) DescribeSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 func(*ec2.DescribeSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSecurityGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSecurityGroupsPagesWithContext indicates an expected call of DescribeSecurityGroupsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsPagesWithContext), varargs...) +} + +// DescribeSecurityGroupsRequest mocks base method +func (m *MockEC2API) DescribeSecurityGroupsRequest(arg0 *ec2.DescribeSecurityGroupsInput) (*request.Request, *ec2.DescribeSecurityGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSecurityGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSecurityGroupsOutput) + return ret0, ret1 +} + +// DescribeSecurityGroupsRequest indicates an expected call of DescribeSecurityGroupsRequest +func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsRequest), arg0) +} + +// DescribeSecurityGroupsWithContext mocks base method +func (m *MockEC2API) DescribeSecurityGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSecurityGroupsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSecurityGroupsWithContext indicates an expected call of DescribeSecurityGroupsWithContext +func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsWithContext), varargs...) +} + +// DescribeSnapshotAttribute mocks base method +func (m *MockEC2API) DescribeSnapshotAttribute(arg0 *ec2.DescribeSnapshotAttributeInput) (*ec2.DescribeSnapshotAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSnapshotAttribute", arg0) + ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSnapshotAttribute indicates an expected call of DescribeSnapshotAttribute +func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttribute), arg0) +} + +// DescribeSnapshotAttributeRequest mocks base method +func (m *MockEC2API) DescribeSnapshotAttributeRequest(arg0 *ec2.DescribeSnapshotAttributeInput) (*request.Request, *ec2.DescribeSnapshotAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSnapshotAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSnapshotAttributeOutput) + return ret0, ret1 +} + +// DescribeSnapshotAttributeRequest indicates an expected call of DescribeSnapshotAttributeRequest +func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttributeRequest), arg0) +} + +// DescribeSnapshotAttributeWithContext mocks base method +func (m *MockEC2API) DescribeSnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotAttributeInput, arg2 ...request.Option) (*ec2.DescribeSnapshotAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSnapshotAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSnapshotAttributeWithContext indicates an expected call of DescribeSnapshotAttributeWithContext +func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttributeWithContext), varargs...) +} + +// DescribeSnapshots mocks base method +func (m *MockEC2API) DescribeSnapshots(arg0 *ec2.DescribeSnapshotsInput) (*ec2.DescribeSnapshotsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSnapshots", arg0) + ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSnapshots indicates an expected call of DescribeSnapshots +func (mr *MockEC2APIMockRecorder) DescribeSnapshots(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshots", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshots), arg0) +} + +// DescribeSnapshotsPages mocks base method +func (m *MockEC2API) DescribeSnapshotsPages(arg0 *ec2.DescribeSnapshotsInput, arg1 func(*ec2.DescribeSnapshotsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSnapshotsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSnapshotsPages indicates an expected call of DescribeSnapshotsPages +func (mr *MockEC2APIMockRecorder) DescribeSnapshotsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsPages), arg0, arg1) +} + +// DescribeSnapshotsPagesWithContext mocks base method +func (m *MockEC2API) DescribeSnapshotsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 func(*ec2.DescribeSnapshotsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSnapshotsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSnapshotsPagesWithContext indicates an expected call of DescribeSnapshotsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeSnapshotsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsPagesWithContext), varargs...) +} + +// DescribeSnapshotsRequest mocks base method +func (m *MockEC2API) DescribeSnapshotsRequest(arg0 *ec2.DescribeSnapshotsInput) (*request.Request, *ec2.DescribeSnapshotsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSnapshotsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSnapshotsOutput) + return ret0, ret1 +} + +// DescribeSnapshotsRequest indicates an expected call of DescribeSnapshotsRequest +func (mr *MockEC2APIMockRecorder) DescribeSnapshotsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsRequest), arg0) +} + +// DescribeSnapshotsWithContext mocks base method +func (m *MockEC2API) DescribeSnapshotsWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeSnapshotsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSnapshotsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSnapshotsWithContext indicates an expected call of DescribeSnapshotsWithContext +func (mr *MockEC2APIMockRecorder) DescribeSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsWithContext), varargs...) +} + +// DescribeSpotDatafeedSubscription mocks base method +func (m *MockEC2API) DescribeSpotDatafeedSubscription(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscription", arg0) + ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotDatafeedSubscription indicates an expected call of DescribeSpotDatafeedSubscription +func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscription), arg0) +} + +// DescribeSpotDatafeedSubscriptionRequest mocks base method +func (m *MockEC2API) DescribeSpotDatafeedSubscriptionRequest(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSpotDatafeedSubscriptionOutput) + return ret0, ret1 +} + +// DescribeSpotDatafeedSubscriptionRequest indicates an expected call of DescribeSpotDatafeedSubscriptionRequest +func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionRequest), arg0) +} + +// DescribeSpotDatafeedSubscriptionWithContext mocks base method +func (m *MockEC2API) DescribeSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotDatafeedSubscriptionWithContext indicates an expected call of DescribeSpotDatafeedSubscriptionWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionWithContext), varargs...) +} + +// DescribeSpotFleetInstances mocks base method +func (m *MockEC2API) DescribeSpotFleetInstances(arg0 *ec2.DescribeSpotFleetInstancesInput) (*ec2.DescribeSpotFleetInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotFleetInstances", arg0) + ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotFleetInstances indicates an expected call of DescribeSpotFleetInstances +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstances), arg0) +} + +// DescribeSpotFleetInstancesRequest mocks base method +func (m *MockEC2API) DescribeSpotFleetInstancesRequest(arg0 *ec2.DescribeSpotFleetInstancesInput) (*request.Request, *ec2.DescribeSpotFleetInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSpotFleetInstancesOutput) + return ret0, ret1 +} + +// DescribeSpotFleetInstancesRequest indicates an expected call of DescribeSpotFleetInstancesRequest +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstancesRequest), arg0) +} + +// DescribeSpotFleetInstancesWithContext mocks base method +func (m *MockEC2API) DescribeSpotFleetInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotFleetInstancesWithContext indicates an expected call of DescribeSpotFleetInstancesWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstancesWithContext), varargs...) +} + +// DescribeSpotFleetRequestHistory mocks base method +func (m *MockEC2API) DescribeSpotFleetRequestHistory(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistory", arg0) + ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotFleetRequestHistory indicates an expected call of DescribeSpotFleetRequestHistory +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistory(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistory), arg0) +} + +// DescribeSpotFleetRequestHistoryRequest mocks base method +func (m *MockEC2API) DescribeSpotFleetRequestHistoryRequest(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*request.Request, *ec2.DescribeSpotFleetRequestHistoryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestHistoryOutput) + return ret0, ret1 +} + +// DescribeSpotFleetRequestHistoryRequest indicates an expected call of DescribeSpotFleetRequestHistoryRequest +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistoryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryRequest), arg0) +} + +// DescribeSpotFleetRequestHistoryWithContext mocks base method +func (m *MockEC2API) DescribeSpotFleetRequestHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotFleetRequestHistoryWithContext indicates an expected call of DescribeSpotFleetRequestHistoryWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryWithContext), varargs...) +} + +// DescribeSpotFleetRequests mocks base method +func (m *MockEC2API) DescribeSpotFleetRequests(arg0 *ec2.DescribeSpotFleetRequestsInput) (*ec2.DescribeSpotFleetRequestsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotFleetRequests", arg0) + ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotFleetRequests indicates an expected call of DescribeSpotFleetRequests +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequests(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequests), arg0) +} + +// DescribeSpotFleetRequestsPages mocks base method +func (m *MockEC2API) DescribeSpotFleetRequestsPages(arg0 *ec2.DescribeSpotFleetRequestsInput, arg1 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSpotFleetRequestsPages indicates an expected call of DescribeSpotFleetRequestsPages +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsPages), arg0, arg1) +} + +// DescribeSpotFleetRequestsPagesWithContext mocks base method +func (m *MockEC2API) DescribeSpotFleetRequestsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSpotFleetRequestsPagesWithContext indicates an expected call of DescribeSpotFleetRequestsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsPagesWithContext), varargs...) +} + +// DescribeSpotFleetRequestsRequest mocks base method +func (m *MockEC2API) DescribeSpotFleetRequestsRequest(arg0 *ec2.DescribeSpotFleetRequestsInput) (*request.Request, *ec2.DescribeSpotFleetRequestsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestsOutput) + return ret0, ret1 +} + +// DescribeSpotFleetRequestsRequest indicates an expected call of DescribeSpotFleetRequestsRequest +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsRequest), arg0) +} + +// DescribeSpotFleetRequestsWithContext mocks base method +func (m *MockEC2API) DescribeSpotFleetRequestsWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotFleetRequestsWithContext indicates an expected call of DescribeSpotFleetRequestsWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsWithContext), varargs...) +} + +// DescribeSpotInstanceRequests mocks base method +func (m *MockEC2API) DescribeSpotInstanceRequests(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*ec2.DescribeSpotInstanceRequestsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotInstanceRequests", arg0) + ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotInstanceRequests indicates an expected call of DescribeSpotInstanceRequests +func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequests(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequests), arg0) +} + +// DescribeSpotInstanceRequestsPages mocks base method +func (m *MockEC2API) DescribeSpotInstanceRequestsPages(arg0 *ec2.DescribeSpotInstanceRequestsInput, arg1 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSpotInstanceRequestsPages indicates an expected call of DescribeSpotInstanceRequestsPages +func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsPages), arg0, arg1) +} + +// DescribeSpotInstanceRequestsPagesWithContext mocks base method +func (m *MockEC2API) DescribeSpotInstanceRequestsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSpotInstanceRequestsPagesWithContext indicates an expected call of DescribeSpotInstanceRequestsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsPagesWithContext), varargs...) +} + +// DescribeSpotInstanceRequestsRequest mocks base method +func (m *MockEC2API) DescribeSpotInstanceRequestsRequest(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*request.Request, *ec2.DescribeSpotInstanceRequestsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSpotInstanceRequestsOutput) + return ret0, ret1 +} + +// DescribeSpotInstanceRequestsRequest indicates an expected call of DescribeSpotInstanceRequestsRequest +func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsRequest), arg0) +} + +// DescribeSpotInstanceRequestsWithContext mocks base method +func (m *MockEC2API) DescribeSpotInstanceRequestsWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotInstanceRequestsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotInstanceRequestsWithContext indicates an expected call of DescribeSpotInstanceRequestsWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsWithContext), varargs...) +} + +// DescribeSpotPriceHistory mocks base method +func (m *MockEC2API) DescribeSpotPriceHistory(arg0 *ec2.DescribeSpotPriceHistoryInput) (*ec2.DescribeSpotPriceHistoryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotPriceHistory", arg0) + ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotPriceHistory indicates an expected call of DescribeSpotPriceHistory +func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistory(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistory), arg0) +} + +// DescribeSpotPriceHistoryPages mocks base method +func (m *MockEC2API) DescribeSpotPriceHistoryPages(arg0 *ec2.DescribeSpotPriceHistoryInput, arg1 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSpotPriceHistoryPages indicates an expected call of DescribeSpotPriceHistoryPages +func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryPages), arg0, arg1) +} + +// DescribeSpotPriceHistoryPagesWithContext mocks base method +func (m *MockEC2API) DescribeSpotPriceHistoryPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSpotPriceHistoryPagesWithContext indicates an expected call of DescribeSpotPriceHistoryPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryPagesWithContext), varargs...) +} + +// DescribeSpotPriceHistoryRequest mocks base method +func (m *MockEC2API) DescribeSpotPriceHistoryRequest(arg0 *ec2.DescribeSpotPriceHistoryInput) (*request.Request, *ec2.DescribeSpotPriceHistoryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSpotPriceHistoryOutput) + return ret0, ret1 +} + +// DescribeSpotPriceHistoryRequest indicates an expected call of DescribeSpotPriceHistoryRequest +func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryRequest), arg0) +} + +// DescribeSpotPriceHistoryWithContext mocks base method +func (m *MockEC2API) DescribeSpotPriceHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotPriceHistoryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSpotPriceHistoryWithContext indicates an expected call of DescribeSpotPriceHistoryWithContext +func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryWithContext), varargs...) +} + +// DescribeStaleSecurityGroups mocks base method +func (m *MockEC2API) DescribeStaleSecurityGroups(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*ec2.DescribeStaleSecurityGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeStaleSecurityGroups", arg0) + ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeStaleSecurityGroups indicates an expected call of DescribeStaleSecurityGroups +func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroups), arg0) +} + +// DescribeStaleSecurityGroupsPages mocks base method +func (m *MockEC2API) DescribeStaleSecurityGroupsPages(arg0 *ec2.DescribeStaleSecurityGroupsInput, arg1 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeStaleSecurityGroupsPages indicates an expected call of DescribeStaleSecurityGroupsPages +func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsPages), arg0, arg1) +} + +// DescribeStaleSecurityGroupsPagesWithContext mocks base method +func (m *MockEC2API) DescribeStaleSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeStaleSecurityGroupsPagesWithContext indicates an expected call of DescribeStaleSecurityGroupsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsPagesWithContext), varargs...) +} + +// DescribeStaleSecurityGroupsRequest mocks base method +func (m *MockEC2API) DescribeStaleSecurityGroupsRequest(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*request.Request, *ec2.DescribeStaleSecurityGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeStaleSecurityGroupsOutput) + return ret0, ret1 +} + +// DescribeStaleSecurityGroupsRequest indicates an expected call of DescribeStaleSecurityGroupsRequest +func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsRequest), arg0) +} + +// DescribeStaleSecurityGroupsWithContext mocks base method +func (m *MockEC2API) DescribeStaleSecurityGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeStaleSecurityGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeStaleSecurityGroupsWithContext indicates an expected call of DescribeStaleSecurityGroupsWithContext +func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsWithContext), varargs...) +} + +// DescribeSubnets mocks base method +func (m *MockEC2API) DescribeSubnets(arg0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSubnets", arg0) + ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSubnets indicates an expected call of DescribeSubnets +func (mr *MockEC2APIMockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnets), arg0) +} + +// DescribeSubnetsPages mocks base method +func (m *MockEC2API) DescribeSubnetsPages(arg0 *ec2.DescribeSubnetsInput, arg1 func(*ec2.DescribeSubnetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSubnetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSubnetsPages indicates an expected call of DescribeSubnetsPages +func (mr *MockEC2APIMockRecorder) DescribeSubnetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPages), arg0, arg1) +} + +// DescribeSubnetsPagesWithContext mocks base method +func (m *MockEC2API) DescribeSubnetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 func(*ec2.DescribeSubnetsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSubnetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeSubnetsPagesWithContext indicates an expected call of DescribeSubnetsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeSubnetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPagesWithContext), varargs...) +} + +// DescribeSubnetsRequest mocks base method +func (m *MockEC2API) DescribeSubnetsRequest(arg0 *ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSubnetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeSubnetsOutput) + return ret0, ret1 +} + +// DescribeSubnetsRequest indicates an expected call of DescribeSubnetsRequest +func (mr *MockEC2APIMockRecorder) DescribeSubnetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsRequest), arg0) +} + +// DescribeSubnetsWithContext mocks base method +func (m *MockEC2API) DescribeSubnetsWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.Option) (*ec2.DescribeSubnetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSubnetsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSubnetsWithContext indicates an expected call of DescribeSubnetsWithContext +func (mr *MockEC2APIMockRecorder) DescribeSubnetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsWithContext), varargs...) +} + +// DescribeTags mocks base method +func (m *MockEC2API) DescribeTags(arg0 *ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTags", arg0) + ret0, _ := ret[0].(*ec2.DescribeTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTags indicates an expected call of DescribeTags +func (mr *MockEC2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockEC2API)(nil).DescribeTags), arg0) +} + +// DescribeTagsPages mocks base method +func (m *MockEC2API) DescribeTagsPages(arg0 *ec2.DescribeTagsInput, arg1 func(*ec2.DescribeTagsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTagsPages indicates an expected call of DescribeTagsPages +func (mr *MockEC2APIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPages), arg0, arg1) +} + +// DescribeTagsPagesWithContext mocks base method +func (m *MockEC2API) DescribeTagsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTagsInput, arg2 func(*ec2.DescribeTagsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTagsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTagsPagesWithContext indicates an expected call of DescribeTagsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTagsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPagesWithContext), varargs...) +} + +// DescribeTagsRequest mocks base method +func (m *MockEC2API) DescribeTagsRequest(arg0 *ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTagsOutput) + return ret0, ret1 +} + +// DescribeTagsRequest indicates an expected call of DescribeTagsRequest +func (mr *MockEC2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsRequest), arg0) +} + +// DescribeTagsWithContext mocks base method +func (m *MockEC2API) DescribeTagsWithContext(arg0 context.Context, arg1 *ec2.DescribeTagsInput, arg2 ...request.Option) (*ec2.DescribeTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTagsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext +func (mr *MockEC2APIMockRecorder) DescribeTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsWithContext), varargs...) +} + +// DescribeTrafficMirrorFilters mocks base method +func (m *MockEC2API) DescribeTrafficMirrorFilters(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*ec2.DescribeTrafficMirrorFiltersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilters", arg0) + ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrafficMirrorFilters indicates an expected call of DescribeTrafficMirrorFilters +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilters(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilters", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilters), arg0) +} + +// DescribeTrafficMirrorFiltersPages mocks base method +func (m *MockEC2API) DescribeTrafficMirrorFiltersPages(arg0 *ec2.DescribeTrafficMirrorFiltersInput, arg1 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTrafficMirrorFiltersPages indicates an expected call of DescribeTrafficMirrorFiltersPages +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPages), arg0, arg1) +} + +// DescribeTrafficMirrorFiltersPagesWithContext mocks base method +func (m *MockEC2API) DescribeTrafficMirrorFiltersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTrafficMirrorFiltersPagesWithContext indicates an expected call of DescribeTrafficMirrorFiltersPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPagesWithContext), varargs...) +} + +// DescribeTrafficMirrorFiltersRequest mocks base method +func (m *MockEC2API) DescribeTrafficMirrorFiltersRequest(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*request.Request, *ec2.DescribeTrafficMirrorFiltersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorFiltersOutput) + return ret0, ret1 +} + +// DescribeTrafficMirrorFiltersRequest indicates an expected call of DescribeTrafficMirrorFiltersRequest +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersRequest), arg0) +} + +// DescribeTrafficMirrorFiltersWithContext mocks base method +func (m *MockEC2API) DescribeTrafficMirrorFiltersWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorFiltersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrafficMirrorFiltersWithContext indicates an expected call of DescribeTrafficMirrorFiltersWithContext +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersWithContext), varargs...) +} + +// DescribeTrafficMirrorSessions mocks base method +func (m *MockEC2API) DescribeTrafficMirrorSessions(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*ec2.DescribeTrafficMirrorSessionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessions", arg0) + ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrafficMirrorSessions indicates an expected call of DescribeTrafficMirrorSessions +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessions", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessions), arg0) +} + +// DescribeTrafficMirrorSessionsPages mocks base method +func (m *MockEC2API) DescribeTrafficMirrorSessionsPages(arg0 *ec2.DescribeTrafficMirrorSessionsInput, arg1 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTrafficMirrorSessionsPages indicates an expected call of DescribeTrafficMirrorSessionsPages +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPages), arg0, arg1) +} + +// DescribeTrafficMirrorSessionsPagesWithContext mocks base method +func (m *MockEC2API) DescribeTrafficMirrorSessionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTrafficMirrorSessionsPagesWithContext indicates an expected call of DescribeTrafficMirrorSessionsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPagesWithContext), varargs...) +} + +// DescribeTrafficMirrorSessionsRequest mocks base method +func (m *MockEC2API) DescribeTrafficMirrorSessionsRequest(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*request.Request, *ec2.DescribeTrafficMirrorSessionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorSessionsOutput) + return ret0, ret1 +} + +// DescribeTrafficMirrorSessionsRequest indicates an expected call of DescribeTrafficMirrorSessionsRequest +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsRequest), arg0) +} + +// DescribeTrafficMirrorSessionsWithContext mocks base method +func (m *MockEC2API) DescribeTrafficMirrorSessionsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorSessionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrafficMirrorSessionsWithContext indicates an expected call of DescribeTrafficMirrorSessionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsWithContext), varargs...) +} + +// DescribeTrafficMirrorTargets mocks base method +func (m *MockEC2API) DescribeTrafficMirrorTargets(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*ec2.DescribeTrafficMirrorTargetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargets", arg0) + ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrafficMirrorTargets indicates an expected call of DescribeTrafficMirrorTargets +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargets", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargets), arg0) +} + +// DescribeTrafficMirrorTargetsPages mocks base method +func (m *MockEC2API) DescribeTrafficMirrorTargetsPages(arg0 *ec2.DescribeTrafficMirrorTargetsInput, arg1 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTrafficMirrorTargetsPages indicates an expected call of DescribeTrafficMirrorTargetsPages +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPages), arg0, arg1) +} + +// DescribeTrafficMirrorTargetsPagesWithContext mocks base method +func (m *MockEC2API) DescribeTrafficMirrorTargetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTrafficMirrorTargetsPagesWithContext indicates an expected call of DescribeTrafficMirrorTargetsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPagesWithContext), varargs...) +} + +// DescribeTrafficMirrorTargetsRequest mocks base method +func (m *MockEC2API) DescribeTrafficMirrorTargetsRequest(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*request.Request, *ec2.DescribeTrafficMirrorTargetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorTargetsOutput) + return ret0, ret1 +} + +// DescribeTrafficMirrorTargetsRequest indicates an expected call of DescribeTrafficMirrorTargetsRequest +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsRequest), arg0) +} + +// DescribeTrafficMirrorTargetsWithContext mocks base method +func (m *MockEC2API) DescribeTrafficMirrorTargetsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorTargetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrafficMirrorTargetsWithContext indicates an expected call of DescribeTrafficMirrorTargetsWithContext +func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsWithContext), varargs...) +} + +// DescribeTransitGatewayAttachments mocks base method +func (m *MockEC2API) DescribeTransitGatewayAttachments(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachments", arg0) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayAttachments indicates an expected call of DescribeTransitGatewayAttachments +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachments(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachments), arg0) +} + +// DescribeTransitGatewayAttachmentsPages mocks base method +func (m *MockEC2API) DescribeTransitGatewayAttachmentsPages(arg0 *ec2.DescribeTransitGatewayAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayAttachmentsPages indicates an expected call of DescribeTransitGatewayAttachmentsPages +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPages), arg0, arg1) +} + +// DescribeTransitGatewayAttachmentsPagesWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayAttachmentsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPagesWithContext), varargs...) +} + +// DescribeTransitGatewayAttachmentsRequest mocks base method +func (m *MockEC2API) DescribeTransitGatewayAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayAttachmentsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTransitGatewayAttachmentsOutput) + return ret0, ret1 +} + +// DescribeTransitGatewayAttachmentsRequest indicates an expected call of DescribeTransitGatewayAttachmentsRequest +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsRequest), arg0) +} + +// DescribeTransitGatewayAttachmentsWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayAttachmentsWithContext indicates an expected call of DescribeTransitGatewayAttachmentsWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsWithContext), varargs...) +} + +// DescribeTransitGatewayMulticastDomains mocks base method +func (m *MockEC2API) DescribeTransitGatewayMulticastDomains(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomains", arg0) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayMulticastDomainsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayMulticastDomains indicates an expected call of DescribeTransitGatewayMulticastDomains +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomains(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomains", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomains), arg0) +} + +// DescribeTransitGatewayMulticastDomainsPages mocks base method +func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsPages(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg1 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayMulticastDomainsPages indicates an expected call of DescribeTransitGatewayMulticastDomainsPages +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsPages), arg0, arg1) +} + +// DescribeTransitGatewayMulticastDomainsPagesWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg2 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayMulticastDomainsPagesWithContext indicates an expected call of DescribeTransitGatewayMulticastDomainsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsPagesWithContext), varargs...) +} + +// DescribeTransitGatewayMulticastDomainsRequest mocks base method +func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsRequest(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*request.Request, *ec2.DescribeTransitGatewayMulticastDomainsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTransitGatewayMulticastDomainsOutput) + return ret0, ret1 +} + +// DescribeTransitGatewayMulticastDomainsRequest indicates an expected call of DescribeTransitGatewayMulticastDomainsRequest +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsRequest), arg0) +} + +// DescribeTransitGatewayMulticastDomainsWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayMulticastDomainsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayMulticastDomainsWithContext indicates an expected call of DescribeTransitGatewayMulticastDomainsWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsWithContext), varargs...) +} + +// DescribeTransitGatewayPeeringAttachments mocks base method +func (m *MockEC2API) DescribeTransitGatewayPeeringAttachments(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachments", arg0) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayPeeringAttachments indicates an expected call of DescribeTransitGatewayPeeringAttachments +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachments(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachments), arg0) +} + +// DescribeTransitGatewayPeeringAttachmentsPages mocks base method +func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsPages(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayPeeringAttachmentsPages indicates an expected call of DescribeTransitGatewayPeeringAttachmentsPages +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsPages), arg0, arg1) +} + +// DescribeTransitGatewayPeeringAttachmentsPagesWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayPeeringAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayPeeringAttachmentsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsPagesWithContext), varargs...) +} + +// DescribeTransitGatewayPeeringAttachmentsRequest mocks base method +func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayPeeringAttachmentsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput) + return ret0, ret1 +} + +// DescribeTransitGatewayPeeringAttachmentsRequest indicates an expected call of DescribeTransitGatewayPeeringAttachmentsRequest +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsRequest), arg0) +} + +// DescribeTransitGatewayPeeringAttachmentsWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayPeeringAttachmentsWithContext indicates an expected call of DescribeTransitGatewayPeeringAttachmentsWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsWithContext), varargs...) +} + +// DescribeTransitGatewayRouteTables mocks base method +func (m *MockEC2API) DescribeTransitGatewayRouteTables(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTables", arg0) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayRouteTables indicates an expected call of DescribeTransitGatewayRouteTables +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTables(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTables), arg0) +} + +// DescribeTransitGatewayRouteTablesPages mocks base method +func (m *MockEC2API) DescribeTransitGatewayRouteTablesPages(arg0 *ec2.DescribeTransitGatewayRouteTablesInput, arg1 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayRouteTablesPages indicates an expected call of DescribeTransitGatewayRouteTablesPages +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPages), arg0, arg1) +} + +// DescribeTransitGatewayRouteTablesPagesWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayRouteTablesPagesWithContext indicates an expected call of DescribeTransitGatewayRouteTablesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPagesWithContext), varargs...) +} + +// DescribeTransitGatewayRouteTablesRequest mocks base method +func (m *MockEC2API) DescribeTransitGatewayRouteTablesRequest(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTablesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTransitGatewayRouteTablesOutput) + return ret0, ret1 +} + +// DescribeTransitGatewayRouteTablesRequest indicates an expected call of DescribeTransitGatewayRouteTablesRequest +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesRequest), arg0) +} + +// DescribeTransitGatewayRouteTablesWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayRouteTablesWithContext indicates an expected call of DescribeTransitGatewayRouteTablesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesWithContext), varargs...) +} + +// DescribeTransitGatewayVpcAttachments mocks base method +func (m *MockEC2API) DescribeTransitGatewayVpcAttachments(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachments", arg0) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayVpcAttachments indicates an expected call of DescribeTransitGatewayVpcAttachments +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachments(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachments), arg0) +} + +// DescribeTransitGatewayVpcAttachmentsPages mocks base method +func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPages(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayVpcAttachmentsPages indicates an expected call of DescribeTransitGatewayVpcAttachmentsPages +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPages), arg0, arg1) +} + +// DescribeTransitGatewayVpcAttachmentsPagesWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewayVpcAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayVpcAttachmentsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPagesWithContext), varargs...) +} + +// DescribeTransitGatewayVpcAttachmentsRequest mocks base method +func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayVpcAttachmentsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) + return ret0, ret1 +} + +// DescribeTransitGatewayVpcAttachmentsRequest indicates an expected call of DescribeTransitGatewayVpcAttachmentsRequest +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsRequest), arg0) +} + +// DescribeTransitGatewayVpcAttachmentsWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewayVpcAttachmentsWithContext indicates an expected call of DescribeTransitGatewayVpcAttachmentsWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsWithContext), varargs...) +} + +// DescribeTransitGateways mocks base method +func (m *MockEC2API) DescribeTransitGateways(arg0 *ec2.DescribeTransitGatewaysInput) (*ec2.DescribeTransitGatewaysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGateways", arg0) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGateways indicates an expected call of DescribeTransitGateways +func (mr *MockEC2APIMockRecorder) DescribeTransitGateways(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGateways), arg0) +} + +// DescribeTransitGatewaysPages mocks base method +func (m *MockEC2API) DescribeTransitGatewaysPages(arg0 *ec2.DescribeTransitGatewaysInput, arg1 func(*ec2.DescribeTransitGatewaysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewaysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewaysPages indicates an expected call of DescribeTransitGatewaysPages +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysPages), arg0, arg1) +} + +// DescribeTransitGatewaysPagesWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 func(*ec2.DescribeTransitGatewaysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewaysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTransitGatewaysPagesWithContext indicates an expected call of DescribeTransitGatewaysPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysPagesWithContext), varargs...) +} + +// DescribeTransitGatewaysRequest mocks base method +func (m *MockEC2API) DescribeTransitGatewaysRequest(arg0 *ec2.DescribeTransitGatewaysInput) (*request.Request, *ec2.DescribeTransitGatewaysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTransitGatewaysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeTransitGatewaysOutput) + return ret0, ret1 +} + +// DescribeTransitGatewaysRequest indicates an expected call of DescribeTransitGatewaysRequest +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysRequest), arg0) +} + +// DescribeTransitGatewaysWithContext mocks base method +func (m *MockEC2API) DescribeTransitGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewaysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTransitGatewaysWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTransitGatewaysWithContext indicates an expected call of DescribeTransitGatewaysWithContext +func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysWithContext), varargs...) +} + +// DescribeVolumeAttribute mocks base method +func (m *MockEC2API) DescribeVolumeAttribute(arg0 *ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumeAttribute", arg0) + ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVolumeAttribute indicates an expected call of DescribeVolumeAttribute +func (mr *MockEC2APIMockRecorder) DescribeVolumeAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttribute), arg0) +} + +// DescribeVolumeAttributeRequest mocks base method +func (m *MockEC2API) DescribeVolumeAttributeRequest(arg0 *ec2.DescribeVolumeAttributeInput) (*request.Request, *ec2.DescribeVolumeAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumeAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVolumeAttributeOutput) + return ret0, ret1 +} + +// DescribeVolumeAttributeRequest indicates an expected call of DescribeVolumeAttributeRequest +func (mr *MockEC2APIMockRecorder) DescribeVolumeAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttributeRequest), arg0) +} + +// DescribeVolumeAttributeWithContext mocks base method +func (m *MockEC2API) DescribeVolumeAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeAttributeInput, arg2 ...request.Option) (*ec2.DescribeVolumeAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVolumeAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVolumeAttributeWithContext indicates an expected call of DescribeVolumeAttributeWithContext +func (mr *MockEC2APIMockRecorder) DescribeVolumeAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttributeWithContext), varargs...) +} + +// DescribeVolumeStatus mocks base method +func (m *MockEC2API) DescribeVolumeStatus(arg0 *ec2.DescribeVolumeStatusInput) (*ec2.DescribeVolumeStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumeStatus", arg0) + ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVolumeStatus indicates an expected call of DescribeVolumeStatus +func (mr *MockEC2APIMockRecorder) DescribeVolumeStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatus), arg0) +} + +// DescribeVolumeStatusPages mocks base method +func (m *MockEC2API) DescribeVolumeStatusPages(arg0 *ec2.DescribeVolumeStatusInput, arg1 func(*ec2.DescribeVolumeStatusOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumeStatusPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVolumeStatusPages indicates an expected call of DescribeVolumeStatusPages +func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusPages), arg0, arg1) +} + +// DescribeVolumeStatusPagesWithContext mocks base method +func (m *MockEC2API) DescribeVolumeStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 func(*ec2.DescribeVolumeStatusOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVolumeStatusPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVolumeStatusPagesWithContext indicates an expected call of DescribeVolumeStatusPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusPagesWithContext), varargs...) +} + +// DescribeVolumeStatusRequest mocks base method +func (m *MockEC2API) DescribeVolumeStatusRequest(arg0 *ec2.DescribeVolumeStatusInput) (*request.Request, *ec2.DescribeVolumeStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumeStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVolumeStatusOutput) + return ret0, ret1 +} + +// DescribeVolumeStatusRequest indicates an expected call of DescribeVolumeStatusRequest +func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusRequest), arg0) +} + +// DescribeVolumeStatusWithContext mocks base method +func (m *MockEC2API) DescribeVolumeStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 ...request.Option) (*ec2.DescribeVolumeStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVolumeStatusWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVolumeStatusWithContext indicates an expected call of DescribeVolumeStatusWithContext +func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusWithContext), varargs...) +} + +// DescribeVolumes mocks base method +func (m *MockEC2API) DescribeVolumes(arg0 *ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumes", arg0) + ret0, _ := ret[0].(*ec2.DescribeVolumesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVolumes indicates an expected call of DescribeVolumes +func (mr *MockEC2APIMockRecorder) DescribeVolumes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumes", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumes), arg0) +} + +// DescribeVolumesModifications mocks base method +func (m *MockEC2API) DescribeVolumesModifications(arg0 *ec2.DescribeVolumesModificationsInput) (*ec2.DescribeVolumesModificationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumesModifications", arg0) + ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVolumesModifications indicates an expected call of DescribeVolumesModifications +func (mr *MockEC2APIMockRecorder) DescribeVolumesModifications(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModifications), arg0) +} + +// DescribeVolumesModificationsPages mocks base method +func (m *MockEC2API) DescribeVolumesModificationsPages(arg0 *ec2.DescribeVolumesModificationsInput, arg1 func(*ec2.DescribeVolumesModificationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumesModificationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVolumesModificationsPages indicates an expected call of DescribeVolumesModificationsPages +func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsPages), arg0, arg1) +} + +// DescribeVolumesModificationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeVolumesModificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 func(*ec2.DescribeVolumesModificationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVolumesModificationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVolumesModificationsPagesWithContext indicates an expected call of DescribeVolumesModificationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsPagesWithContext), varargs...) +} + +// DescribeVolumesModificationsRequest mocks base method +func (m *MockEC2API) DescribeVolumesModificationsRequest(arg0 *ec2.DescribeVolumesModificationsInput) (*request.Request, *ec2.DescribeVolumesModificationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumesModificationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVolumesModificationsOutput) + return ret0, ret1 +} + +// DescribeVolumesModificationsRequest indicates an expected call of DescribeVolumesModificationsRequest +func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsRequest), arg0) +} + +// DescribeVolumesModificationsWithContext mocks base method +func (m *MockEC2API) DescribeVolumesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVolumesModificationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVolumesModificationsWithContext indicates an expected call of DescribeVolumesModificationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsWithContext), varargs...) +} + +// DescribeVolumesPages mocks base method +func (m *MockEC2API) DescribeVolumesPages(arg0 *ec2.DescribeVolumesInput, arg1 func(*ec2.DescribeVolumesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVolumesPages indicates an expected call of DescribeVolumesPages +func (mr *MockEC2APIMockRecorder) DescribeVolumesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesPages), arg0, arg1) +} + +// DescribeVolumesPagesWithContext mocks base method +func (m *MockEC2API) DescribeVolumesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 func(*ec2.DescribeVolumesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVolumesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVolumesPagesWithContext indicates an expected call of DescribeVolumesPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVolumesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesPagesWithContext), varargs...) +} + +// DescribeVolumesRequest mocks base method +func (m *MockEC2API) DescribeVolumesRequest(arg0 *ec2.DescribeVolumesInput) (*request.Request, *ec2.DescribeVolumesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVolumesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVolumesOutput) + return ret0, ret1 +} + +// DescribeVolumesRequest indicates an expected call of DescribeVolumesRequest +func (mr *MockEC2APIMockRecorder) DescribeVolumesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesRequest), arg0) +} + +// DescribeVolumesWithContext mocks base method +func (m *MockEC2API) DescribeVolumesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.Option) (*ec2.DescribeVolumesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVolumesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVolumesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVolumesWithContext indicates an expected call of DescribeVolumesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVolumesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesWithContext), varargs...) +} + +// DescribeVpcAttribute mocks base method +func (m *MockEC2API) DescribeVpcAttribute(arg0 *ec2.DescribeVpcAttributeInput) (*ec2.DescribeVpcAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcAttribute", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcAttribute indicates an expected call of DescribeVpcAttribute +func (mr *MockEC2APIMockRecorder) DescribeVpcAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttribute), arg0) +} + +// DescribeVpcAttributeRequest mocks base method +func (m *MockEC2API) DescribeVpcAttributeRequest(arg0 *ec2.DescribeVpcAttributeInput) (*request.Request, *ec2.DescribeVpcAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcAttributeOutput) + return ret0, ret1 +} + +// DescribeVpcAttributeRequest indicates an expected call of DescribeVpcAttributeRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttributeRequest), arg0) +} + +// DescribeVpcAttributeWithContext mocks base method +func (m *MockEC2API) DescribeVpcAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcAttributeInput, arg2 ...request.Option) (*ec2.DescribeVpcAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcAttributeWithContext indicates an expected call of DescribeVpcAttributeWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttributeWithContext), varargs...) +} + +// DescribeVpcClassicLink mocks base method +func (m *MockEC2API) DescribeVpcClassicLink(arg0 *ec2.DescribeVpcClassicLinkInput) (*ec2.DescribeVpcClassicLinkOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcClassicLink", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcClassicLink indicates an expected call of DescribeVpcClassicLink +func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLink(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLink), arg0) +} + +// DescribeVpcClassicLinkDnsSupport mocks base method +func (m *MockEC2API) DescribeVpcClassicLinkDnsSupport(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupport", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcClassicLinkDnsSupport indicates an expected call of DescribeVpcClassicLinkDnsSupport +func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupport), arg0) +} + +// DescribeVpcClassicLinkDnsSupportPages mocks base method +func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPages(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg1 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcClassicLinkDnsSupportPages indicates an expected call of DescribeVpcClassicLinkDnsSupportPages +func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPages), arg0, arg1) +} + +// DescribeVpcClassicLinkDnsSupportPagesWithContext mocks base method +func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcClassicLinkDnsSupportPagesWithContext indicates an expected call of DescribeVpcClassicLinkDnsSupportPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPagesWithContext), varargs...) +} + +// DescribeVpcClassicLinkDnsSupportRequest mocks base method +func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportRequest(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DescribeVpcClassicLinkDnsSupportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) + return ret0, ret1 +} + +// DescribeVpcClassicLinkDnsSupportRequest indicates an expected call of DescribeVpcClassicLinkDnsSupportRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportRequest), arg0) +} + +// DescribeVpcClassicLinkDnsSupportWithContext mocks base method +func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcClassicLinkDnsSupportWithContext indicates an expected call of DescribeVpcClassicLinkDnsSupportWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportWithContext), varargs...) +} + +// DescribeVpcClassicLinkRequest mocks base method +func (m *MockEC2API) DescribeVpcClassicLinkRequest(arg0 *ec2.DescribeVpcClassicLinkInput) (*request.Request, *ec2.DescribeVpcClassicLinkOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcClassicLinkRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkOutput) + return ret0, ret1 +} + +// DescribeVpcClassicLinkRequest indicates an expected call of DescribeVpcClassicLinkRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkRequest), arg0) +} + +// DescribeVpcClassicLinkWithContext mocks base method +func (m *MockEC2API) DescribeVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcClassicLinkWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcClassicLinkWithContext indicates an expected call of DescribeVpcClassicLinkWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkWithContext), varargs...) +} + +// DescribeVpcEndpointConnectionNotifications mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionNotifications(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotifications", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointConnectionNotifications indicates an expected call of DescribeVpcEndpointConnectionNotifications +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotifications), arg0) +} + +// DescribeVpcEndpointConnectionNotificationsPages mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPages(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointConnectionNotificationsPages indicates an expected call of DescribeVpcEndpointConnectionNotificationsPages +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPages), arg0, arg1) +} + +// DescribeVpcEndpointConnectionNotificationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointConnectionNotificationsPagesWithContext indicates an expected call of DescribeVpcEndpointConnectionNotificationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPagesWithContext), varargs...) +} + +// DescribeVpcEndpointConnectionNotificationsRequest mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionNotificationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) + return ret0, ret1 +} + +// DescribeVpcEndpointConnectionNotificationsRequest indicates an expected call of DescribeVpcEndpointConnectionNotificationsRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsRequest), arg0) +} + +// DescribeVpcEndpointConnectionNotificationsWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointConnectionNotificationsWithContext indicates an expected call of DescribeVpcEndpointConnectionNotificationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsWithContext), varargs...) +} + +// DescribeVpcEndpointConnections mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnections(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*ec2.DescribeVpcEndpointConnectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnections", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointConnections indicates an expected call of DescribeVpcEndpointConnections +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnections), arg0) +} + +// DescribeVpcEndpointConnectionsPages mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionsPages(arg0 *ec2.DescribeVpcEndpointConnectionsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointConnectionsPages indicates an expected call of DescribeVpcEndpointConnectionsPages +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPages), arg0, arg1) +} + +// DescribeVpcEndpointConnectionsPagesWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointConnectionsPagesWithContext indicates an expected call of DescribeVpcEndpointConnectionsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPagesWithContext), varargs...) +} + +// DescribeVpcEndpointConnectionsRequest mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionsRequest(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionsOutput) + return ret0, ret1 +} + +// DescribeVpcEndpointConnectionsRequest indicates an expected call of DescribeVpcEndpointConnectionsRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsRequest), arg0) +} + +// DescribeVpcEndpointConnectionsWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointConnectionsWithContext indicates an expected call of DescribeVpcEndpointConnectionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsWithContext), varargs...) +} + +// DescribeVpcEndpointServiceConfigurations mocks base method +func (m *MockEC2API) DescribeVpcEndpointServiceConfigurations(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurations", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointServiceConfigurations indicates an expected call of DescribeVpcEndpointServiceConfigurations +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurations), arg0) +} + +// DescribeVpcEndpointServiceConfigurationsPages mocks base method +func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPages(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg1 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointServiceConfigurationsPages indicates an expected call of DescribeVpcEndpointServiceConfigurationsPages +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPages), arg0, arg1) +} + +// DescribeVpcEndpointServiceConfigurationsPagesWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointServiceConfigurationsPagesWithContext indicates an expected call of DescribeVpcEndpointServiceConfigurationsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPagesWithContext), varargs...) +} + +// DescribeVpcEndpointServiceConfigurationsRequest mocks base method +func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DescribeVpcEndpointServiceConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) + return ret0, ret1 +} + +// DescribeVpcEndpointServiceConfigurationsRequest indicates an expected call of DescribeVpcEndpointServiceConfigurationsRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsRequest), arg0) +} + +// DescribeVpcEndpointServiceConfigurationsWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointServiceConfigurationsWithContext indicates an expected call of DescribeVpcEndpointServiceConfigurationsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsWithContext), varargs...) +} + +// DescribeVpcEndpointServicePermissions mocks base method +func (m *MockEC2API) DescribeVpcEndpointServicePermissions(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissions", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointServicePermissions indicates an expected call of DescribeVpcEndpointServicePermissions +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissions), arg0) +} + +// DescribeVpcEndpointServicePermissionsPages mocks base method +func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPages(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput, arg1 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointServicePermissionsPages indicates an expected call of DescribeVpcEndpointServicePermissionsPages +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPages), arg0, arg1) +} + +// DescribeVpcEndpointServicePermissionsPagesWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointServicePermissionsPagesWithContext indicates an expected call of DescribeVpcEndpointServicePermissionsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPagesWithContext), varargs...) +} + +// DescribeVpcEndpointServicePermissionsRequest mocks base method +func (m *MockEC2API) DescribeVpcEndpointServicePermissionsRequest(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*request.Request, *ec2.DescribeVpcEndpointServicePermissionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicePermissionsOutput) + return ret0, ret1 +} + +// DescribeVpcEndpointServicePermissionsRequest indicates an expected call of DescribeVpcEndpointServicePermissionsRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsRequest), arg0) +} + +// DescribeVpcEndpointServicePermissionsWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointServicePermissionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointServicePermissionsWithContext indicates an expected call of DescribeVpcEndpointServicePermissionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsWithContext), varargs...) +} + +// DescribeVpcEndpointServices mocks base method +func (m *MockEC2API) DescribeVpcEndpointServices(arg0 *ec2.DescribeVpcEndpointServicesInput) (*ec2.DescribeVpcEndpointServicesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointServices", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointServices indicates an expected call of DescribeVpcEndpointServices +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServices(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServices", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServices), arg0) +} + +// DescribeVpcEndpointServicesRequest mocks base method +func (m *MockEC2API) DescribeVpcEndpointServicesRequest(arg0 *ec2.DescribeVpcEndpointServicesInput) (*request.Request, *ec2.DescribeVpcEndpointServicesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicesOutput) + return ret0, ret1 +} + +// DescribeVpcEndpointServicesRequest indicates an expected call of DescribeVpcEndpointServicesRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicesRequest), arg0) +} + +// DescribeVpcEndpointServicesWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointServicesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicesInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointServicesWithContext indicates an expected call of DescribeVpcEndpointServicesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicesWithContext), varargs...) +} + +// DescribeVpcEndpoints mocks base method +func (m *MockEC2API) DescribeVpcEndpoints(arg0 *ec2.DescribeVpcEndpointsInput) (*ec2.DescribeVpcEndpointsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpoints", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpoints indicates an expected call of DescribeVpcEndpoints +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpoints(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpoints), arg0) +} + +// DescribeVpcEndpointsPages mocks base method +func (m *MockEC2API) DescribeVpcEndpointsPages(arg0 *ec2.DescribeVpcEndpointsInput, arg1 func(*ec2.DescribeVpcEndpointsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointsPages indicates an expected call of DescribeVpcEndpointsPages +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPages), arg0, arg1) +} + +// DescribeVpcEndpointsPagesWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 func(*ec2.DescribeVpcEndpointsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcEndpointsPagesWithContext indicates an expected call of DescribeVpcEndpointsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPagesWithContext), varargs...) +} + +// DescribeVpcEndpointsRequest mocks base method +func (m *MockEC2API) DescribeVpcEndpointsRequest(arg0 *ec2.DescribeVpcEndpointsInput) (*request.Request, *ec2.DescribeVpcEndpointsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcEndpointsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcEndpointsOutput) + return ret0, ret1 +} + +// DescribeVpcEndpointsRequest indicates an expected call of DescribeVpcEndpointsRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsRequest), arg0) +} + +// DescribeVpcEndpointsWithContext mocks base method +func (m *MockEC2API) DescribeVpcEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcEndpointsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcEndpointsWithContext indicates an expected call of DescribeVpcEndpointsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsWithContext), varargs...) +} + +// DescribeVpcPeeringConnections mocks base method +func (m *MockEC2API) DescribeVpcPeeringConnections(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*ec2.DescribeVpcPeeringConnectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcPeeringConnections", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcPeeringConnections indicates an expected call of DescribeVpcPeeringConnections +func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnections), arg0) +} + +// DescribeVpcPeeringConnectionsPages mocks base method +func (m *MockEC2API) DescribeVpcPeeringConnectionsPages(arg0 *ec2.DescribeVpcPeeringConnectionsInput, arg1 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcPeeringConnectionsPages indicates an expected call of DescribeVpcPeeringConnectionsPages +func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPages), arg0, arg1) +} + +// DescribeVpcPeeringConnectionsPagesWithContext mocks base method +func (m *MockEC2API) DescribeVpcPeeringConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcPeeringConnectionsPagesWithContext indicates an expected call of DescribeVpcPeeringConnectionsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPagesWithContext), varargs...) +} + +// DescribeVpcPeeringConnectionsRequest mocks base method +func (m *MockEC2API) DescribeVpcPeeringConnectionsRequest(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*request.Request, *ec2.DescribeVpcPeeringConnectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcPeeringConnectionsOutput) + return ret0, ret1 +} + +// DescribeVpcPeeringConnectionsRequest indicates an expected call of DescribeVpcPeeringConnectionsRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsRequest), arg0) +} + +// DescribeVpcPeeringConnectionsWithContext mocks base method +func (m *MockEC2API) DescribeVpcPeeringConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcPeeringConnectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcPeeringConnectionsWithContext indicates an expected call of DescribeVpcPeeringConnectionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsWithContext), varargs...) +} + +// DescribeVpcs mocks base method +func (m *MockEC2API) DescribeVpcs(arg0 *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcs", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpcsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcs indicates an expected call of DescribeVpcs +func (mr *MockEC2APIMockRecorder) DescribeVpcs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcs", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcs), arg0) +} + +// DescribeVpcsPages mocks base method +func (m *MockEC2API) DescribeVpcsPages(arg0 *ec2.DescribeVpcsInput, arg1 func(*ec2.DescribeVpcsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcsPages indicates an expected call of DescribeVpcsPages +func (mr *MockEC2APIMockRecorder) DescribeVpcsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsPages), arg0, arg1) +} + +// DescribeVpcsPagesWithContext mocks base method +func (m *MockEC2API) DescribeVpcsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 func(*ec2.DescribeVpcsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeVpcsPagesWithContext indicates an expected call of DescribeVpcsPagesWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsPagesWithContext), varargs...) +} + +// DescribeVpcsRequest mocks base method +func (m *MockEC2API) DescribeVpcsRequest(arg0 *ec2.DescribeVpcsInput) (*request.Request, *ec2.DescribeVpcsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpcsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpcsOutput) + return ret0, ret1 +} + +// DescribeVpcsRequest indicates an expected call of DescribeVpcsRequest +func (mr *MockEC2APIMockRecorder) DescribeVpcsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsRequest), arg0) +} + +// DescribeVpcsWithContext mocks base method +func (m *MockEC2API) DescribeVpcsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.Option) (*ec2.DescribeVpcsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpcsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpcsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpcsWithContext indicates an expected call of DescribeVpcsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpcsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsWithContext), varargs...) +} + +// DescribeVpnConnections mocks base method +func (m *MockEC2API) DescribeVpnConnections(arg0 *ec2.DescribeVpnConnectionsInput) (*ec2.DescribeVpnConnectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpnConnections", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpnConnections indicates an expected call of DescribeVpnConnections +func (mr *MockEC2APIMockRecorder) DescribeVpnConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnections), arg0) +} + +// DescribeVpnConnectionsRequest mocks base method +func (m *MockEC2API) DescribeVpnConnectionsRequest(arg0 *ec2.DescribeVpnConnectionsInput) (*request.Request, *ec2.DescribeVpnConnectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpnConnectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpnConnectionsOutput) + return ret0, ret1 +} + +// DescribeVpnConnectionsRequest indicates an expected call of DescribeVpnConnectionsRequest +func (mr *MockEC2APIMockRecorder) DescribeVpnConnectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnectionsRequest), arg0) +} + +// DescribeVpnConnectionsWithContext mocks base method +func (m *MockEC2API) DescribeVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpnConnectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpnConnectionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpnConnectionsWithContext indicates an expected call of DescribeVpnConnectionsWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpnConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnectionsWithContext), varargs...) +} + +// DescribeVpnGateways mocks base method +func (m *MockEC2API) DescribeVpnGateways(arg0 *ec2.DescribeVpnGatewaysInput) (*ec2.DescribeVpnGatewaysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpnGateways", arg0) + ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpnGateways indicates an expected call of DescribeVpnGateways +func (mr *MockEC2APIMockRecorder) DescribeVpnGateways(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGateways), arg0) +} + +// DescribeVpnGatewaysRequest mocks base method +func (m *MockEC2API) DescribeVpnGatewaysRequest(arg0 *ec2.DescribeVpnGatewaysInput) (*request.Request, *ec2.DescribeVpnGatewaysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeVpnGatewaysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DescribeVpnGatewaysOutput) + return ret0, ret1 +} + +// DescribeVpnGatewaysRequest indicates an expected call of DescribeVpnGatewaysRequest +func (mr *MockEC2APIMockRecorder) DescribeVpnGatewaysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGatewaysRequest), arg0) +} + +// DescribeVpnGatewaysWithContext mocks base method +func (m *MockEC2API) DescribeVpnGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnGatewaysInput, arg2 ...request.Option) (*ec2.DescribeVpnGatewaysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeVpnGatewaysWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeVpnGatewaysWithContext indicates an expected call of DescribeVpnGatewaysWithContext +func (mr *MockEC2APIMockRecorder) DescribeVpnGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGatewaysWithContext), varargs...) +} + +// DetachClassicLinkVpc mocks base method +func (m *MockEC2API) DetachClassicLinkVpc(arg0 *ec2.DetachClassicLinkVpcInput) (*ec2.DetachClassicLinkVpcOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachClassicLinkVpc", arg0) + ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachClassicLinkVpc indicates an expected call of DetachClassicLinkVpc +func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpc(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpc), arg0) +} + +// DetachClassicLinkVpcRequest mocks base method +func (m *MockEC2API) DetachClassicLinkVpcRequest(arg0 *ec2.DetachClassicLinkVpcInput) (*request.Request, *ec2.DetachClassicLinkVpcOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachClassicLinkVpcRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DetachClassicLinkVpcOutput) + return ret0, ret1 +} + +// DetachClassicLinkVpcRequest indicates an expected call of DetachClassicLinkVpcRequest +func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpcRequest), arg0) +} + +// DetachClassicLinkVpcWithContext mocks base method +func (m *MockEC2API) DetachClassicLinkVpcWithContext(arg0 context.Context, arg1 *ec2.DetachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.DetachClassicLinkVpcOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachClassicLinkVpcWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachClassicLinkVpcWithContext indicates an expected call of DetachClassicLinkVpcWithContext +func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpcWithContext), varargs...) +} + +// DetachInternetGateway mocks base method +func (m *MockEC2API) DetachInternetGateway(arg0 *ec2.DetachInternetGatewayInput) (*ec2.DetachInternetGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachInternetGateway", arg0) + ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachInternetGateway indicates an expected call of DetachInternetGateway +func (mr *MockEC2APIMockRecorder) DetachInternetGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGateway), arg0) +} + +// DetachInternetGatewayRequest mocks base method +func (m *MockEC2API) DetachInternetGatewayRequest(arg0 *ec2.DetachInternetGatewayInput) (*request.Request, *ec2.DetachInternetGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachInternetGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DetachInternetGatewayOutput) + return ret0, ret1 +} + +// DetachInternetGatewayRequest indicates an expected call of DetachInternetGatewayRequest +func (mr *MockEC2APIMockRecorder) DetachInternetGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGatewayRequest), arg0) +} + +// DetachInternetGatewayWithContext mocks base method +func (m *MockEC2API) DetachInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DetachInternetGatewayInput, arg2 ...request.Option) (*ec2.DetachInternetGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachInternetGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachInternetGatewayWithContext indicates an expected call of DetachInternetGatewayWithContext +func (mr *MockEC2APIMockRecorder) DetachInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGatewayWithContext), varargs...) +} + +// DetachNetworkInterface mocks base method +func (m *MockEC2API) DetachNetworkInterface(arg0 *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachNetworkInterface", arg0) + ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachNetworkInterface indicates an expected call of DetachNetworkInterface +func (mr *MockEC2APIMockRecorder) DetachNetworkInterface(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterface), arg0) +} + +// DetachNetworkInterfaceRequest mocks base method +func (m *MockEC2API) DetachNetworkInterfaceRequest(arg0 *ec2.DetachNetworkInterfaceInput) (*request.Request, *ec2.DetachNetworkInterfaceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachNetworkInterfaceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DetachNetworkInterfaceOutput) + return ret0, ret1 +} + +// DetachNetworkInterfaceRequest indicates an expected call of DetachNetworkInterfaceRequest +func (mr *MockEC2APIMockRecorder) DetachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterfaceRequest), arg0) +} + +// DetachNetworkInterfaceWithContext mocks base method +func (m *MockEC2API) DetachNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DetachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DetachNetworkInterfaceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachNetworkInterfaceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachNetworkInterfaceWithContext indicates an expected call of DetachNetworkInterfaceWithContext +func (mr *MockEC2APIMockRecorder) DetachNetworkInterfaceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterfaceWithContext), varargs...) +} + +// DetachVolume mocks base method +func (m *MockEC2API) DetachVolume(arg0 *ec2.DetachVolumeInput) (*ec2.VolumeAttachment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachVolume", arg0) + ret0, _ := ret[0].(*ec2.VolumeAttachment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachVolume indicates an expected call of DetachVolume +func (mr *MockEC2APIMockRecorder) DetachVolume(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolume", reflect.TypeOf((*MockEC2API)(nil).DetachVolume), arg0) +} + +// DetachVolumeRequest mocks base method +func (m *MockEC2API) DetachVolumeRequest(arg0 *ec2.DetachVolumeInput) (*request.Request, *ec2.VolumeAttachment) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachVolumeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.VolumeAttachment) + return ret0, ret1 +} + +// DetachVolumeRequest indicates an expected call of DetachVolumeRequest +func (mr *MockEC2APIMockRecorder) DetachVolumeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVolumeRequest), arg0) +} + +// DetachVolumeWithContext mocks base method +func (m *MockEC2API) DetachVolumeWithContext(arg0 context.Context, arg1 *ec2.DetachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachVolumeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.VolumeAttachment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachVolumeWithContext indicates an expected call of DetachVolumeWithContext +func (mr *MockEC2APIMockRecorder) DetachVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachVolumeWithContext), varargs...) +} + +// DetachVpnGateway mocks base method +func (m *MockEC2API) DetachVpnGateway(arg0 *ec2.DetachVpnGatewayInput) (*ec2.DetachVpnGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachVpnGateway", arg0) + ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachVpnGateway indicates an expected call of DetachVpnGateway +func (mr *MockEC2APIMockRecorder) DetachVpnGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGateway), arg0) +} + +// DetachVpnGatewayRequest mocks base method +func (m *MockEC2API) DetachVpnGatewayRequest(arg0 *ec2.DetachVpnGatewayInput) (*request.Request, *ec2.DetachVpnGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachVpnGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DetachVpnGatewayOutput) + return ret0, ret1 +} + +// DetachVpnGatewayRequest indicates an expected call of DetachVpnGatewayRequest +func (mr *MockEC2APIMockRecorder) DetachVpnGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGatewayRequest), arg0) +} + +// DetachVpnGatewayWithContext mocks base method +func (m *MockEC2API) DetachVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.DetachVpnGatewayInput, arg2 ...request.Option) (*ec2.DetachVpnGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachVpnGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachVpnGatewayWithContext indicates an expected call of DetachVpnGatewayWithContext +func (mr *MockEC2APIMockRecorder) DetachVpnGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGatewayWithContext), varargs...) +} + +// DisableEbsEncryptionByDefault mocks base method +func (m *MockEC2API) DisableEbsEncryptionByDefault(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*ec2.DisableEbsEncryptionByDefaultOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefault", arg0) + ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableEbsEncryptionByDefault indicates an expected call of DisableEbsEncryptionByDefault +func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefault), arg0) +} + +// DisableEbsEncryptionByDefaultRequest mocks base method +func (m *MockEC2API) DisableEbsEncryptionByDefaultRequest(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*request.Request, *ec2.DisableEbsEncryptionByDefaultOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableEbsEncryptionByDefaultOutput) + return ret0, ret1 +} + +// DisableEbsEncryptionByDefaultRequest indicates an expected call of DisableEbsEncryptionByDefaultRequest +func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefaultRequest), arg0) +} + +// DisableEbsEncryptionByDefaultWithContext mocks base method +func (m *MockEC2API) DisableEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.DisableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.DisableEbsEncryptionByDefaultOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableEbsEncryptionByDefaultWithContext indicates an expected call of DisableEbsEncryptionByDefaultWithContext +func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefaultWithContext), varargs...) +} + +// DisableFastSnapshotRestores mocks base method +func (m *MockEC2API) DisableFastSnapshotRestores(arg0 *ec2.DisableFastSnapshotRestoresInput) (*ec2.DisableFastSnapshotRestoresOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableFastSnapshotRestores", arg0) + ret0, _ := ret[0].(*ec2.DisableFastSnapshotRestoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableFastSnapshotRestores indicates an expected call of DisableFastSnapshotRestores +func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestores(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestores), arg0) +} + +// DisableFastSnapshotRestoresRequest mocks base method +func (m *MockEC2API) DisableFastSnapshotRestoresRequest(arg0 *ec2.DisableFastSnapshotRestoresInput) (*request.Request, *ec2.DisableFastSnapshotRestoresOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableFastSnapshotRestoresRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableFastSnapshotRestoresOutput) + return ret0, ret1 +} + +// DisableFastSnapshotRestoresRequest indicates an expected call of DisableFastSnapshotRestoresRequest +func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestoresRequest), arg0) +} + +// DisableFastSnapshotRestoresWithContext mocks base method +func (m *MockEC2API) DisableFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.DisableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.DisableFastSnapshotRestoresOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableFastSnapshotRestoresWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableFastSnapshotRestoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableFastSnapshotRestoresWithContext indicates an expected call of DisableFastSnapshotRestoresWithContext +func (mr *MockEC2APIMockRecorder) DisableFastSnapshotRestoresWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestoresWithContext), varargs...) +} + +// DisableTransitGatewayRouteTablePropagation mocks base method +func (m *MockEC2API) DisableTransitGatewayRouteTablePropagation(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagation", arg0) + ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableTransitGatewayRouteTablePropagation indicates an expected call of DisableTransitGatewayRouteTablePropagation +func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagation), arg0) +} + +// DisableTransitGatewayRouteTablePropagationRequest mocks base method +func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.DisableTransitGatewayRouteTablePropagationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) + return ret0, ret1 +} + +// DisableTransitGatewayRouteTablePropagationRequest indicates an expected call of DisableTransitGatewayRouteTablePropagationRequest +func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationRequest), arg0) +} + +// DisableTransitGatewayRouteTablePropagationWithContext mocks base method +func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationWithContext(arg0 context.Context, arg1 *ec2.DisableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableTransitGatewayRouteTablePropagationWithContext indicates an expected call of DisableTransitGatewayRouteTablePropagationWithContext +func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationWithContext), varargs...) +} + +// DisableVgwRoutePropagation mocks base method +func (m *MockEC2API) DisableVgwRoutePropagation(arg0 *ec2.DisableVgwRoutePropagationInput) (*ec2.DisableVgwRoutePropagationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableVgwRoutePropagation", arg0) + ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableVgwRoutePropagation indicates an expected call of DisableVgwRoutePropagation +func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagation), arg0) +} + +// DisableVgwRoutePropagationRequest mocks base method +func (m *MockEC2API) DisableVgwRoutePropagationRequest(arg0 *ec2.DisableVgwRoutePropagationInput) (*request.Request, *ec2.DisableVgwRoutePropagationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableVgwRoutePropagationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableVgwRoutePropagationOutput) + return ret0, ret1 +} + +// DisableVgwRoutePropagationRequest indicates an expected call of DisableVgwRoutePropagationRequest +func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagationRequest), arg0) +} + +// DisableVgwRoutePropagationWithContext mocks base method +func (m *MockEC2API) DisableVgwRoutePropagationWithContext(arg0 context.Context, arg1 *ec2.DisableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.DisableVgwRoutePropagationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableVgwRoutePropagationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableVgwRoutePropagationWithContext indicates an expected call of DisableVgwRoutePropagationWithContext +func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagationWithContext), varargs...) +} + +// DisableVpcClassicLink mocks base method +func (m *MockEC2API) DisableVpcClassicLink(arg0 *ec2.DisableVpcClassicLinkInput) (*ec2.DisableVpcClassicLinkOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableVpcClassicLink", arg0) + ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableVpcClassicLink indicates an expected call of DisableVpcClassicLink +func (mr *MockEC2APIMockRecorder) DisableVpcClassicLink(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLink), arg0) +} + +// DisableVpcClassicLinkDnsSupport mocks base method +func (m *MockEC2API) DisableVpcClassicLinkDnsSupport(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupport", arg0) + ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableVpcClassicLinkDnsSupport indicates an expected call of DisableVpcClassicLinkDnsSupport +func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupport), arg0) +} + +// DisableVpcClassicLinkDnsSupportRequest mocks base method +func (m *MockEC2API) DisableVpcClassicLinkDnsSupportRequest(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DisableVpcClassicLinkDnsSupportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkDnsSupportOutput) + return ret0, ret1 +} + +// DisableVpcClassicLinkDnsSupportRequest indicates an expected call of DisableVpcClassicLinkDnsSupportRequest +func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportRequest), arg0) +} + +// DisableVpcClassicLinkDnsSupportWithContext mocks base method +func (m *MockEC2API) DisableVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.DisableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableVpcClassicLinkDnsSupportWithContext indicates an expected call of DisableVpcClassicLinkDnsSupportWithContext +func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportWithContext), varargs...) +} + +// DisableVpcClassicLinkRequest mocks base method +func (m *MockEC2API) DisableVpcClassicLinkRequest(arg0 *ec2.DisableVpcClassicLinkInput) (*request.Request, *ec2.DisableVpcClassicLinkOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableVpcClassicLinkRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkOutput) + return ret0, ret1 +} + +// DisableVpcClassicLinkRequest indicates an expected call of DisableVpcClassicLinkRequest +func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkRequest), arg0) +} + +// DisableVpcClassicLinkWithContext mocks base method +func (m *MockEC2API) DisableVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.DisableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableVpcClassicLinkWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableVpcClassicLinkWithContext indicates an expected call of DisableVpcClassicLinkWithContext +func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkWithContext), varargs...) +} + +// DisassociateAddress mocks base method +func (m *MockEC2API) DisassociateAddress(arg0 *ec2.DisassociateAddressInput) (*ec2.DisassociateAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateAddress", arg0) + ret0, _ := ret[0].(*ec2.DisassociateAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateAddress indicates an expected call of DisassociateAddress +func (mr *MockEC2APIMockRecorder) DisassociateAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddress), arg0) +} + +// DisassociateAddressRequest mocks base method +func (m *MockEC2API) DisassociateAddressRequest(arg0 *ec2.DisassociateAddressInput) (*request.Request, *ec2.DisassociateAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateAddressOutput) + return ret0, ret1 +} + +// DisassociateAddressRequest indicates an expected call of DisassociateAddressRequest +func (mr *MockEC2APIMockRecorder) DisassociateAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddressRequest), arg0) +} + +// DisassociateAddressWithContext mocks base method +func (m *MockEC2API) DisassociateAddressWithContext(arg0 context.Context, arg1 *ec2.DisassociateAddressInput, arg2 ...request.Option) (*ec2.DisassociateAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateAddressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateAddressWithContext indicates an expected call of DisassociateAddressWithContext +func (mr *MockEC2APIMockRecorder) DisassociateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddressWithContext), varargs...) +} + +// DisassociateClientVpnTargetNetwork mocks base method +func (m *MockEC2API) DisassociateClientVpnTargetNetwork(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetwork", arg0) + ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateClientVpnTargetNetwork indicates an expected call of DisassociateClientVpnTargetNetwork +func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetwork), arg0) +} + +// DisassociateClientVpnTargetNetworkRequest mocks base method +func (m *MockEC2API) DisassociateClientVpnTargetNetworkRequest(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*request.Request, *ec2.DisassociateClientVpnTargetNetworkOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateClientVpnTargetNetworkOutput) + return ret0, ret1 +} + +// DisassociateClientVpnTargetNetworkRequest indicates an expected call of DisassociateClientVpnTargetNetworkRequest +func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkRequest), arg0) +} + +// DisassociateClientVpnTargetNetworkWithContext mocks base method +func (m *MockEC2API) DisassociateClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.DisassociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateClientVpnTargetNetworkWithContext indicates an expected call of DisassociateClientVpnTargetNetworkWithContext +func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkWithContext), varargs...) +} + +// DisassociateIamInstanceProfile mocks base method +func (m *MockEC2API) DisassociateIamInstanceProfile(arg0 *ec2.DisassociateIamInstanceProfileInput) (*ec2.DisassociateIamInstanceProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateIamInstanceProfile", arg0) + ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateIamInstanceProfile indicates an expected call of DisassociateIamInstanceProfile +func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfile), arg0) +} + +// DisassociateIamInstanceProfileRequest mocks base method +func (m *MockEC2API) DisassociateIamInstanceProfileRequest(arg0 *ec2.DisassociateIamInstanceProfileInput) (*request.Request, *ec2.DisassociateIamInstanceProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateIamInstanceProfileOutput) + return ret0, ret1 +} + +// DisassociateIamInstanceProfileRequest indicates an expected call of DisassociateIamInstanceProfileRequest +func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfileRequest), arg0) +} + +// DisassociateIamInstanceProfileWithContext mocks base method +func (m *MockEC2API) DisassociateIamInstanceProfileWithContext(arg0 context.Context, arg1 *ec2.DisassociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.DisassociateIamInstanceProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateIamInstanceProfileWithContext indicates an expected call of DisassociateIamInstanceProfileWithContext +func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfileWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfileWithContext), varargs...) +} + +// DisassociateRouteTable mocks base method +func (m *MockEC2API) DisassociateRouteTable(arg0 *ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateRouteTable", arg0) + ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateRouteTable indicates an expected call of DisassociateRouteTable +func (mr *MockEC2APIMockRecorder) DisassociateRouteTable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTable), arg0) +} + +// DisassociateRouteTableRequest mocks base method +func (m *MockEC2API) DisassociateRouteTableRequest(arg0 *ec2.DisassociateRouteTableInput) (*request.Request, *ec2.DisassociateRouteTableOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateRouteTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateRouteTableOutput) + return ret0, ret1 +} + +// DisassociateRouteTableRequest indicates an expected call of DisassociateRouteTableRequest +func (mr *MockEC2APIMockRecorder) DisassociateRouteTableRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTableRequest), arg0) +} + +// DisassociateRouteTableWithContext mocks base method +func (m *MockEC2API) DisassociateRouteTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateRouteTableOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateRouteTableWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateRouteTableWithContext indicates an expected call of DisassociateRouteTableWithContext +func (mr *MockEC2APIMockRecorder) DisassociateRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTableWithContext), varargs...) +} + +// DisassociateSubnetCidrBlock mocks base method +func (m *MockEC2API) DisassociateSubnetCidrBlock(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*ec2.DisassociateSubnetCidrBlockOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlock", arg0) + ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateSubnetCidrBlock indicates an expected call of DisassociateSubnetCidrBlock +func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlock), arg0) +} + +// DisassociateSubnetCidrBlockRequest mocks base method +func (m *MockEC2API) DisassociateSubnetCidrBlockRequest(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*request.Request, *ec2.DisassociateSubnetCidrBlockOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateSubnetCidrBlockOutput) + return ret0, ret1 +} + +// DisassociateSubnetCidrBlockRequest indicates an expected call of DisassociateSubnetCidrBlockRequest +func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlockRequest), arg0) +} + +// DisassociateSubnetCidrBlockWithContext mocks base method +func (m *MockEC2API) DisassociateSubnetCidrBlockWithContext(arg0 context.Context, arg1 *ec2.DisassociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateSubnetCidrBlockOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateSubnetCidrBlockWithContext indicates an expected call of DisassociateSubnetCidrBlockWithContext +func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlockWithContext), varargs...) +} + +// DisassociateTransitGatewayMulticastDomain mocks base method +func (m *MockEC2API) DisassociateTransitGatewayMulticastDomain(arg0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomain", arg0) + ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateTransitGatewayMulticastDomain indicates an expected call of DisassociateTransitGatewayMulticastDomain +func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomain), arg0) +} + +// DisassociateTransitGatewayMulticastDomainRequest mocks base method +func (m *MockEC2API) DisassociateTransitGatewayMulticastDomainRequest(arg0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DisassociateTransitGatewayMulticastDomainOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomainRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayMulticastDomainOutput) + return ret0, ret1 +} + +// DisassociateTransitGatewayMulticastDomainRequest indicates an expected call of DisassociateTransitGatewayMulticastDomainRequest +func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomainRequest), arg0) +} + +// DisassociateTransitGatewayMulticastDomainWithContext mocks base method +func (m *MockEC2API) DisassociateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomainWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayMulticastDomainOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateTransitGatewayMulticastDomainWithContext indicates an expected call of DisassociateTransitGatewayMulticastDomainWithContext +func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomainWithContext), varargs...) +} + +// DisassociateTransitGatewayRouteTable mocks base method +func (m *MockEC2API) DisassociateTransitGatewayRouteTable(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTable", arg0) + ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateTransitGatewayRouteTable indicates an expected call of DisassociateTransitGatewayRouteTable +func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTable), arg0) +} + +// DisassociateTransitGatewayRouteTableRequest mocks base method +func (m *MockEC2API) DisassociateTransitGatewayRouteTableRequest(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*request.Request, *ec2.DisassociateTransitGatewayRouteTableOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayRouteTableOutput) + return ret0, ret1 +} + +// DisassociateTransitGatewayRouteTableRequest indicates an expected call of DisassociateTransitGatewayRouteTableRequest +func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableRequest), arg0) +} + +// DisassociateTransitGatewayRouteTableWithContext mocks base method +func (m *MockEC2API) DisassociateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateTransitGatewayRouteTableWithContext indicates an expected call of DisassociateTransitGatewayRouteTableWithContext +func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableWithContext), varargs...) +} + +// DisassociateVpcCidrBlock mocks base method +func (m *MockEC2API) DisassociateVpcCidrBlock(arg0 *ec2.DisassociateVpcCidrBlockInput) (*ec2.DisassociateVpcCidrBlockOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateVpcCidrBlock", arg0) + ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateVpcCidrBlock indicates an expected call of DisassociateVpcCidrBlock +func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlock), arg0) +} + +// DisassociateVpcCidrBlockRequest mocks base method +func (m *MockEC2API) DisassociateVpcCidrBlockRequest(arg0 *ec2.DisassociateVpcCidrBlockInput) (*request.Request, *ec2.DisassociateVpcCidrBlockOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.DisassociateVpcCidrBlockOutput) + return ret0, ret1 +} + +// DisassociateVpcCidrBlockRequest indicates an expected call of DisassociateVpcCidrBlockRequest +func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockRequest), arg0) +} + +// DisassociateVpcCidrBlockWithContext mocks base method +func (m *MockEC2API) DisassociateVpcCidrBlockWithContext(arg0 context.Context, arg1 *ec2.DisassociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateVpcCidrBlockOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockWithContext", varargs...) + ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateVpcCidrBlockWithContext indicates an expected call of DisassociateVpcCidrBlockWithContext +func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockWithContext), varargs...) +} + +// EnableEbsEncryptionByDefault mocks base method +func (m *MockEC2API) EnableEbsEncryptionByDefault(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefault", arg0) + ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableEbsEncryptionByDefault indicates an expected call of EnableEbsEncryptionByDefault +func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefault), arg0) +} + +// EnableEbsEncryptionByDefaultRequest mocks base method +func (m *MockEC2API) EnableEbsEncryptionByDefaultRequest(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*request.Request, *ec2.EnableEbsEncryptionByDefaultOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableEbsEncryptionByDefaultOutput) + return ret0, ret1 +} + +// EnableEbsEncryptionByDefaultRequest indicates an expected call of EnableEbsEncryptionByDefaultRequest +func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultRequest), arg0) +} + +// EnableEbsEncryptionByDefaultWithContext mocks base method +func (m *MockEC2API) EnableEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.EnableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableEbsEncryptionByDefaultWithContext indicates an expected call of EnableEbsEncryptionByDefaultWithContext +func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultWithContext), varargs...) +} + +// EnableFastSnapshotRestores mocks base method +func (m *MockEC2API) EnableFastSnapshotRestores(arg0 *ec2.EnableFastSnapshotRestoresInput) (*ec2.EnableFastSnapshotRestoresOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableFastSnapshotRestores", arg0) + ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableFastSnapshotRestores indicates an expected call of EnableFastSnapshotRestores +func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestores(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestores), arg0) +} + +// EnableFastSnapshotRestoresRequest mocks base method +func (m *MockEC2API) EnableFastSnapshotRestoresRequest(arg0 *ec2.EnableFastSnapshotRestoresInput) (*request.Request, *ec2.EnableFastSnapshotRestoresOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableFastSnapshotRestoresOutput) + return ret0, ret1 +} + +// EnableFastSnapshotRestoresRequest indicates an expected call of EnableFastSnapshotRestoresRequest +func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresRequest), arg0) +} + +// EnableFastSnapshotRestoresWithContext mocks base method +func (m *MockEC2API) EnableFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.EnableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.EnableFastSnapshotRestoresOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableFastSnapshotRestoresWithContext indicates an expected call of EnableFastSnapshotRestoresWithContext +func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresWithContext), varargs...) +} + +// EnableTransitGatewayRouteTablePropagation mocks base method +func (m *MockEC2API) EnableTransitGatewayRouteTablePropagation(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagation", arg0) + ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableTransitGatewayRouteTablePropagation indicates an expected call of EnableTransitGatewayRouteTablePropagation +func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagation), arg0) +} + +// EnableTransitGatewayRouteTablePropagationRequest mocks base method +func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.EnableTransitGatewayRouteTablePropagationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) + return ret0, ret1 +} + +// EnableTransitGatewayRouteTablePropagationRequest indicates an expected call of EnableTransitGatewayRouteTablePropagationRequest +func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationRequest), arg0) +} + +// EnableTransitGatewayRouteTablePropagationWithContext mocks base method +func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationWithContext(arg0 context.Context, arg1 *ec2.EnableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableTransitGatewayRouteTablePropagationWithContext indicates an expected call of EnableTransitGatewayRouteTablePropagationWithContext +func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationWithContext), varargs...) +} + +// EnableVgwRoutePropagation mocks base method +func (m *MockEC2API) EnableVgwRoutePropagation(arg0 *ec2.EnableVgwRoutePropagationInput) (*ec2.EnableVgwRoutePropagationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableVgwRoutePropagation", arg0) + ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableVgwRoutePropagation indicates an expected call of EnableVgwRoutePropagation +func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagation), arg0) +} + +// EnableVgwRoutePropagationRequest mocks base method +func (m *MockEC2API) EnableVgwRoutePropagationRequest(arg0 *ec2.EnableVgwRoutePropagationInput) (*request.Request, *ec2.EnableVgwRoutePropagationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableVgwRoutePropagationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableVgwRoutePropagationOutput) + return ret0, ret1 +} + +// EnableVgwRoutePropagationRequest indicates an expected call of EnableVgwRoutePropagationRequest +func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagationRequest), arg0) +} + +// EnableVgwRoutePropagationWithContext mocks base method +func (m *MockEC2API) EnableVgwRoutePropagationWithContext(arg0 context.Context, arg1 *ec2.EnableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.EnableVgwRoutePropagationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableVgwRoutePropagationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableVgwRoutePropagationWithContext indicates an expected call of EnableVgwRoutePropagationWithContext +func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagationWithContext), varargs...) +} + +// EnableVolumeIO mocks base method +func (m *MockEC2API) EnableVolumeIO(arg0 *ec2.EnableVolumeIOInput) (*ec2.EnableVolumeIOOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableVolumeIO", arg0) + ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableVolumeIO indicates an expected call of EnableVolumeIO +func (mr *MockEC2APIMockRecorder) EnableVolumeIO(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIO", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIO), arg0) +} + +// EnableVolumeIORequest mocks base method +func (m *MockEC2API) EnableVolumeIORequest(arg0 *ec2.EnableVolumeIOInput) (*request.Request, *ec2.EnableVolumeIOOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableVolumeIORequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableVolumeIOOutput) + return ret0, ret1 +} + +// EnableVolumeIORequest indicates an expected call of EnableVolumeIORequest +func (mr *MockEC2APIMockRecorder) EnableVolumeIORequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIORequest", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIORequest), arg0) +} + +// EnableVolumeIOWithContext mocks base method +func (m *MockEC2API) EnableVolumeIOWithContext(arg0 context.Context, arg1 *ec2.EnableVolumeIOInput, arg2 ...request.Option) (*ec2.EnableVolumeIOOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableVolumeIOWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableVolumeIOWithContext indicates an expected call of EnableVolumeIOWithContext +func (mr *MockEC2APIMockRecorder) EnableVolumeIOWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIOWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIOWithContext), varargs...) +} + +// EnableVpcClassicLink mocks base method +func (m *MockEC2API) EnableVpcClassicLink(arg0 *ec2.EnableVpcClassicLinkInput) (*ec2.EnableVpcClassicLinkOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableVpcClassicLink", arg0) + ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableVpcClassicLink indicates an expected call of EnableVpcClassicLink +func (mr *MockEC2APIMockRecorder) EnableVpcClassicLink(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLink), arg0) +} + +// EnableVpcClassicLinkDnsSupport mocks base method +func (m *MockEC2API) EnableVpcClassicLinkDnsSupport(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupport", arg0) + ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableVpcClassicLinkDnsSupport indicates an expected call of EnableVpcClassicLinkDnsSupport +func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupport), arg0) +} + +// EnableVpcClassicLinkDnsSupportRequest mocks base method +func (m *MockEC2API) EnableVpcClassicLinkDnsSupportRequest(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.EnableVpcClassicLinkDnsSupportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkDnsSupportOutput) + return ret0, ret1 +} + +// EnableVpcClassicLinkDnsSupportRequest indicates an expected call of EnableVpcClassicLinkDnsSupportRequest +func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportRequest), arg0) +} + +// EnableVpcClassicLinkDnsSupportWithContext mocks base method +func (m *MockEC2API) EnableVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.EnableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableVpcClassicLinkDnsSupportWithContext indicates an expected call of EnableVpcClassicLinkDnsSupportWithContext +func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportWithContext), varargs...) +} + +// EnableVpcClassicLinkRequest mocks base method +func (m *MockEC2API) EnableVpcClassicLinkRequest(arg0 *ec2.EnableVpcClassicLinkInput) (*request.Request, *ec2.EnableVpcClassicLinkOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableVpcClassicLinkRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkOutput) + return ret0, ret1 +} + +// EnableVpcClassicLinkRequest indicates an expected call of EnableVpcClassicLinkRequest +func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkRequest), arg0) +} + +// EnableVpcClassicLinkWithContext mocks base method +func (m *MockEC2API) EnableVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.EnableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableVpcClassicLinkWithContext", varargs...) + ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableVpcClassicLinkWithContext indicates an expected call of EnableVpcClassicLinkWithContext +func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkWithContext), varargs...) +} + +// ExportClientVpnClientCertificateRevocationList mocks base method +func (m *MockEC2API) ExportClientVpnClientCertificateRevocationList(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationList", arg0) + ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportClientVpnClientCertificateRevocationList indicates an expected call of ExportClientVpnClientCertificateRevocationList +func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationList), arg0) +} + +// ExportClientVpnClientCertificateRevocationListRequest mocks base method +func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ExportClientVpnClientCertificateRevocationListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) + return ret0, ret1 +} + +// ExportClientVpnClientCertificateRevocationListRequest indicates an expected call of ExportClientVpnClientCertificateRevocationListRequest +func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListRequest), arg0) +} + +// ExportClientVpnClientCertificateRevocationListWithContext mocks base method +func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListWithContext(arg0 context.Context, arg1 *ec2.ExportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportClientVpnClientCertificateRevocationListWithContext indicates an expected call of ExportClientVpnClientCertificateRevocationListWithContext +func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationListWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListWithContext), varargs...) +} + +// ExportClientVpnClientConfiguration mocks base method +func (m *MockEC2API) ExportClientVpnClientConfiguration(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*ec2.ExportClientVpnClientConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportClientVpnClientConfiguration", arg0) + ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportClientVpnClientConfiguration indicates an expected call of ExportClientVpnClientConfiguration +func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfiguration", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfiguration), arg0) +} + +// ExportClientVpnClientConfigurationRequest mocks base method +func (m *MockEC2API) ExportClientVpnClientConfigurationRequest(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*request.Request, *ec2.ExportClientVpnClientConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ExportClientVpnClientConfigurationOutput) + return ret0, ret1 +} + +// ExportClientVpnClientConfigurationRequest indicates an expected call of ExportClientVpnClientConfigurationRequest +func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfigurationRequest), arg0) +} + +// ExportClientVpnClientConfigurationWithContext mocks base method +func (m *MockEC2API) ExportClientVpnClientConfigurationWithContext(arg0 context.Context, arg1 *ec2.ExportClientVpnClientConfigurationInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportClientVpnClientConfigurationWithContext indicates an expected call of ExportClientVpnClientConfigurationWithContext +func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfigurationWithContext), varargs...) +} + +// ExportImage mocks base method +func (m *MockEC2API) ExportImage(arg0 *ec2.ExportImageInput) (*ec2.ExportImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportImage", arg0) + ret0, _ := ret[0].(*ec2.ExportImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportImage indicates an expected call of ExportImage +func (mr *MockEC2APIMockRecorder) ExportImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImage", reflect.TypeOf((*MockEC2API)(nil).ExportImage), arg0) +} + +// ExportImageRequest mocks base method +func (m *MockEC2API) ExportImageRequest(arg0 *ec2.ExportImageInput) (*request.Request, *ec2.ExportImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ExportImageOutput) + return ret0, ret1 +} + +// ExportImageRequest indicates an expected call of ExportImageRequest +func (mr *MockEC2APIMockRecorder) ExportImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ExportImageRequest), arg0) +} + +// ExportImageWithContext mocks base method +func (m *MockEC2API) ExportImageWithContext(arg0 context.Context, arg1 *ec2.ExportImageInput, arg2 ...request.Option) (*ec2.ExportImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ExportImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ExportImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportImageWithContext indicates an expected call of ExportImageWithContext +func (mr *MockEC2APIMockRecorder) ExportImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImageWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportImageWithContext), varargs...) +} + +// ExportTransitGatewayRoutes mocks base method +func (m *MockEC2API) ExportTransitGatewayRoutes(arg0 *ec2.ExportTransitGatewayRoutesInput) (*ec2.ExportTransitGatewayRoutesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportTransitGatewayRoutes", arg0) + ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportTransitGatewayRoutes indicates an expected call of ExportTransitGatewayRoutes +func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutes), arg0) +} + +// ExportTransitGatewayRoutesRequest mocks base method +func (m *MockEC2API) ExportTransitGatewayRoutesRequest(arg0 *ec2.ExportTransitGatewayRoutesInput) (*request.Request, *ec2.ExportTransitGatewayRoutesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ExportTransitGatewayRoutesOutput) + return ret0, ret1 +} + +// ExportTransitGatewayRoutesRequest indicates an expected call of ExportTransitGatewayRoutesRequest +func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesRequest), arg0) +} + +// ExportTransitGatewayRoutesWithContext mocks base method +func (m *MockEC2API) ExportTransitGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.ExportTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.ExportTransitGatewayRoutesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExportTransitGatewayRoutesWithContext indicates an expected call of ExportTransitGatewayRoutesWithContext +func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesWithContext), varargs...) +} + +// GetAssociatedIpv6PoolCidrs mocks base method +func (m *MockEC2API) GetAssociatedIpv6PoolCidrs(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrs", arg0) + ret0, _ := ret[0].(*ec2.GetAssociatedIpv6PoolCidrsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAssociatedIpv6PoolCidrs indicates an expected call of GetAssociatedIpv6PoolCidrs +func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrs", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrs), arg0) +} + +// GetAssociatedIpv6PoolCidrsPages mocks base method +func (m *MockEC2API) GetAssociatedIpv6PoolCidrsPages(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput, arg1 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetAssociatedIpv6PoolCidrsPages indicates an expected call of GetAssociatedIpv6PoolCidrsPages +func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsPages), arg0, arg1) +} + +// GetAssociatedIpv6PoolCidrsPagesWithContext mocks base method +func (m *MockEC2API) GetAssociatedIpv6PoolCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedIpv6PoolCidrsInput, arg2 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetAssociatedIpv6PoolCidrsPagesWithContext indicates an expected call of GetAssociatedIpv6PoolCidrsPagesWithContext +func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsPagesWithContext), varargs...) +} + +// GetAssociatedIpv6PoolCidrsRequest mocks base method +func (m *MockEC2API) GetAssociatedIpv6PoolCidrsRequest(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*request.Request, *ec2.GetAssociatedIpv6PoolCidrsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetAssociatedIpv6PoolCidrsOutput) + return ret0, ret1 +} + +// GetAssociatedIpv6PoolCidrsRequest indicates an expected call of GetAssociatedIpv6PoolCidrsRequest +func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsRequest), arg0) +} + +// GetAssociatedIpv6PoolCidrsWithContext mocks base method +func (m *MockEC2API) GetAssociatedIpv6PoolCidrsWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedIpv6PoolCidrsInput, arg2 ...request.Option) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetAssociatedIpv6PoolCidrsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAssociatedIpv6PoolCidrsWithContext indicates an expected call of GetAssociatedIpv6PoolCidrsWithContext +func (mr *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsWithContext), varargs...) +} + +// GetCapacityReservationUsage mocks base method +func (m *MockEC2API) GetCapacityReservationUsage(arg0 *ec2.GetCapacityReservationUsageInput) (*ec2.GetCapacityReservationUsageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCapacityReservationUsage", arg0) + ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCapacityReservationUsage indicates an expected call of GetCapacityReservationUsage +func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsage", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsage), arg0) +} + +// GetCapacityReservationUsageRequest mocks base method +func (m *MockEC2API) GetCapacityReservationUsageRequest(arg0 *ec2.GetCapacityReservationUsageInput) (*request.Request, *ec2.GetCapacityReservationUsageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCapacityReservationUsageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetCapacityReservationUsageOutput) + return ret0, ret1 +} + +// GetCapacityReservationUsageRequest indicates an expected call of GetCapacityReservationUsageRequest +func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageRequest), arg0) +} + +// GetCapacityReservationUsageWithContext mocks base method +func (m *MockEC2API) GetCapacityReservationUsageWithContext(arg0 context.Context, arg1 *ec2.GetCapacityReservationUsageInput, arg2 ...request.Option) (*ec2.GetCapacityReservationUsageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetCapacityReservationUsageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCapacityReservationUsageWithContext indicates an expected call of GetCapacityReservationUsageWithContext +func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageWithContext", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageWithContext), varargs...) +} + +// GetCoipPoolUsage mocks base method +func (m *MockEC2API) GetCoipPoolUsage(arg0 *ec2.GetCoipPoolUsageInput) (*ec2.GetCoipPoolUsageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCoipPoolUsage", arg0) + ret0, _ := ret[0].(*ec2.GetCoipPoolUsageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCoipPoolUsage indicates an expected call of GetCoipPoolUsage +func (mr *MockEC2APIMockRecorder) GetCoipPoolUsage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsage", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsage), arg0) +} + +// GetCoipPoolUsageRequest mocks base method +func (m *MockEC2API) GetCoipPoolUsageRequest(arg0 *ec2.GetCoipPoolUsageInput) (*request.Request, *ec2.GetCoipPoolUsageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCoipPoolUsageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetCoipPoolUsageOutput) + return ret0, ret1 +} + +// GetCoipPoolUsageRequest indicates an expected call of GetCoipPoolUsageRequest +func (mr *MockEC2APIMockRecorder) GetCoipPoolUsageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsageRequest), arg0) +} + +// GetCoipPoolUsageWithContext mocks base method +func (m *MockEC2API) GetCoipPoolUsageWithContext(arg0 context.Context, arg1 *ec2.GetCoipPoolUsageInput, arg2 ...request.Option) (*ec2.GetCoipPoolUsageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetCoipPoolUsageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetCoipPoolUsageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCoipPoolUsageWithContext indicates an expected call of GetCoipPoolUsageWithContext +func (mr *MockEC2APIMockRecorder) GetCoipPoolUsageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsageWithContext", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsageWithContext), varargs...) +} + +// GetConsoleOutput mocks base method +func (m *MockEC2API) GetConsoleOutput(arg0 *ec2.GetConsoleOutputInput) (*ec2.GetConsoleOutputOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConsoleOutput", arg0) + ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConsoleOutput indicates an expected call of GetConsoleOutput +func (mr *MockEC2APIMockRecorder) GetConsoleOutput(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutput", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutput), arg0) +} + +// GetConsoleOutputRequest mocks base method +func (m *MockEC2API) GetConsoleOutputRequest(arg0 *ec2.GetConsoleOutputInput) (*request.Request, *ec2.GetConsoleOutputOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConsoleOutputRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetConsoleOutputOutput) + return ret0, ret1 +} + +// GetConsoleOutputRequest indicates an expected call of GetConsoleOutputRequest +func (mr *MockEC2APIMockRecorder) GetConsoleOutputRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutputRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutputRequest), arg0) +} + +// GetConsoleOutputWithContext mocks base method +func (m *MockEC2API) GetConsoleOutputWithContext(arg0 context.Context, arg1 *ec2.GetConsoleOutputInput, arg2 ...request.Option) (*ec2.GetConsoleOutputOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetConsoleOutputWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConsoleOutputWithContext indicates an expected call of GetConsoleOutputWithContext +func (mr *MockEC2APIMockRecorder) GetConsoleOutputWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutputWithContext", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutputWithContext), varargs...) +} + +// GetConsoleScreenshot mocks base method +func (m *MockEC2API) GetConsoleScreenshot(arg0 *ec2.GetConsoleScreenshotInput) (*ec2.GetConsoleScreenshotOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConsoleScreenshot", arg0) + ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConsoleScreenshot indicates an expected call of GetConsoleScreenshot +func (mr *MockEC2APIMockRecorder) GetConsoleScreenshot(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshot", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshot), arg0) +} + +// GetConsoleScreenshotRequest mocks base method +func (m *MockEC2API) GetConsoleScreenshotRequest(arg0 *ec2.GetConsoleScreenshotInput) (*request.Request, *ec2.GetConsoleScreenshotOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConsoleScreenshotRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetConsoleScreenshotOutput) + return ret0, ret1 +} + +// GetConsoleScreenshotRequest indicates an expected call of GetConsoleScreenshotRequest +func (mr *MockEC2APIMockRecorder) GetConsoleScreenshotRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshotRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshotRequest), arg0) +} + +// GetConsoleScreenshotWithContext mocks base method +func (m *MockEC2API) GetConsoleScreenshotWithContext(arg0 context.Context, arg1 *ec2.GetConsoleScreenshotInput, arg2 ...request.Option) (*ec2.GetConsoleScreenshotOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetConsoleScreenshotWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetConsoleScreenshotWithContext indicates an expected call of GetConsoleScreenshotWithContext +func (mr *MockEC2APIMockRecorder) GetConsoleScreenshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshotWithContext", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshotWithContext), varargs...) +} + +// GetDefaultCreditSpecification mocks base method +func (m *MockEC2API) GetDefaultCreditSpecification(arg0 *ec2.GetDefaultCreditSpecificationInput) (*ec2.GetDefaultCreditSpecificationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDefaultCreditSpecification", arg0) + ret0, _ := ret[0].(*ec2.GetDefaultCreditSpecificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDefaultCreditSpecification indicates an expected call of GetDefaultCreditSpecification +func (mr *MockEC2APIMockRecorder) GetDefaultCreditSpecification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecification), arg0) +} + +// GetDefaultCreditSpecificationRequest mocks base method +func (m *MockEC2API) GetDefaultCreditSpecificationRequest(arg0 *ec2.GetDefaultCreditSpecificationInput) (*request.Request, *ec2.GetDefaultCreditSpecificationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDefaultCreditSpecificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetDefaultCreditSpecificationOutput) + return ret0, ret1 +} + +// GetDefaultCreditSpecificationRequest indicates an expected call of GetDefaultCreditSpecificationRequest +func (mr *MockEC2APIMockRecorder) GetDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecificationRequest), arg0) +} + +// GetDefaultCreditSpecificationWithContext mocks base method +func (m *MockEC2API) GetDefaultCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.GetDefaultCreditSpecificationInput, arg2 ...request.Option) (*ec2.GetDefaultCreditSpecificationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetDefaultCreditSpecificationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetDefaultCreditSpecificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDefaultCreditSpecificationWithContext indicates an expected call of GetDefaultCreditSpecificationWithContext +func (mr *MockEC2APIMockRecorder) GetDefaultCreditSpecificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecificationWithContext", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecificationWithContext), varargs...) +} + +// GetEbsDefaultKmsKeyId mocks base method +func (m *MockEC2API) GetEbsDefaultKmsKeyId(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyId", arg0) + ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetEbsDefaultKmsKeyId indicates an expected call of GetEbsDefaultKmsKeyId +func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyId), arg0) +} + +// GetEbsDefaultKmsKeyIdRequest mocks base method +func (m *MockEC2API) GetEbsDefaultKmsKeyIdRequest(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.GetEbsDefaultKmsKeyIdOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetEbsDefaultKmsKeyIdOutput) + return ret0, ret1 +} + +// GetEbsDefaultKmsKeyIdRequest indicates an expected call of GetEbsDefaultKmsKeyIdRequest +func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdRequest), arg0) +} + +// GetEbsDefaultKmsKeyIdWithContext mocks base method +func (m *MockEC2API) GetEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.GetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetEbsDefaultKmsKeyIdWithContext indicates an expected call of GetEbsDefaultKmsKeyIdWithContext +func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdWithContext), varargs...) +} + +// GetEbsEncryptionByDefault mocks base method +func (m *MockEC2API) GetEbsEncryptionByDefault(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*ec2.GetEbsEncryptionByDefaultOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEbsEncryptionByDefault", arg0) + ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetEbsEncryptionByDefault indicates an expected call of GetEbsEncryptionByDefault +func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefault), arg0) +} + +// GetEbsEncryptionByDefaultRequest mocks base method +func (m *MockEC2API) GetEbsEncryptionByDefaultRequest(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*request.Request, *ec2.GetEbsEncryptionByDefaultOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetEbsEncryptionByDefaultOutput) + return ret0, ret1 +} + +// GetEbsEncryptionByDefaultRequest indicates an expected call of GetEbsEncryptionByDefaultRequest +func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultRequest), arg0) +} + +// GetEbsEncryptionByDefaultWithContext mocks base method +func (m *MockEC2API) GetEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.GetEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.GetEbsEncryptionByDefaultOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetEbsEncryptionByDefaultWithContext indicates an expected call of GetEbsEncryptionByDefaultWithContext +func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultWithContext), varargs...) +} + +// GetGroupsForCapacityReservation mocks base method +func (m *MockEC2API) GetGroupsForCapacityReservation(arg0 *ec2.GetGroupsForCapacityReservationInput) (*ec2.GetGroupsForCapacityReservationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGroupsForCapacityReservation", arg0) + ret0, _ := ret[0].(*ec2.GetGroupsForCapacityReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGroupsForCapacityReservation indicates an expected call of GetGroupsForCapacityReservation +func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservation), arg0) +} + +// GetGroupsForCapacityReservationPages mocks base method +func (m *MockEC2API) GetGroupsForCapacityReservationPages(arg0 *ec2.GetGroupsForCapacityReservationInput, arg1 func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetGroupsForCapacityReservationPages indicates an expected call of GetGroupsForCapacityReservationPages +func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationPages", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationPages), arg0, arg1) +} + +// GetGroupsForCapacityReservationPagesWithContext mocks base method +func (m *MockEC2API) GetGroupsForCapacityReservationPagesWithContext(arg0 context.Context, arg1 *ec2.GetGroupsForCapacityReservationInput, arg2 func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetGroupsForCapacityReservationPagesWithContext indicates an expected call of GetGroupsForCapacityReservationPagesWithContext +func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationPagesWithContext), varargs...) +} + +// GetGroupsForCapacityReservationRequest mocks base method +func (m *MockEC2API) GetGroupsForCapacityReservationRequest(arg0 *ec2.GetGroupsForCapacityReservationInput) (*request.Request, *ec2.GetGroupsForCapacityReservationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetGroupsForCapacityReservationOutput) + return ret0, ret1 +} + +// GetGroupsForCapacityReservationRequest indicates an expected call of GetGroupsForCapacityReservationRequest +func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationRequest), arg0) +} + +// GetGroupsForCapacityReservationWithContext mocks base method +func (m *MockEC2API) GetGroupsForCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.GetGroupsForCapacityReservationInput, arg2 ...request.Option) (*ec2.GetGroupsForCapacityReservationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetGroupsForCapacityReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGroupsForCapacityReservationWithContext indicates an expected call of GetGroupsForCapacityReservationWithContext +func (mr *MockEC2APIMockRecorder) GetGroupsForCapacityReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).GetGroupsForCapacityReservationWithContext), varargs...) +} + +// GetHostReservationPurchasePreview mocks base method +func (m *MockEC2API) GetHostReservationPurchasePreview(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*ec2.GetHostReservationPurchasePreviewOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostReservationPurchasePreview", arg0) + ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostReservationPurchasePreview indicates an expected call of GetHostReservationPurchasePreview +func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreview(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreview", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreview), arg0) +} + +// GetHostReservationPurchasePreviewRequest mocks base method +func (m *MockEC2API) GetHostReservationPurchasePreviewRequest(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*request.Request, *ec2.GetHostReservationPurchasePreviewOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetHostReservationPurchasePreviewOutput) + return ret0, ret1 +} + +// GetHostReservationPurchasePreviewRequest indicates an expected call of GetHostReservationPurchasePreviewRequest +func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreviewRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreviewRequest", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreviewRequest), arg0) +} + +// GetHostReservationPurchasePreviewWithContext mocks base method +func (m *MockEC2API) GetHostReservationPurchasePreviewWithContext(arg0 context.Context, arg1 *ec2.GetHostReservationPurchasePreviewInput, arg2 ...request.Option) (*ec2.GetHostReservationPurchasePreviewOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostReservationPurchasePreviewWithContext indicates an expected call of GetHostReservationPurchasePreviewWithContext +func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreviewWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreviewWithContext", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreviewWithContext), varargs...) +} + +// GetLaunchTemplateData mocks base method +func (m *MockEC2API) GetLaunchTemplateData(arg0 *ec2.GetLaunchTemplateDataInput) (*ec2.GetLaunchTemplateDataOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLaunchTemplateData", arg0) + ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLaunchTemplateData indicates an expected call of GetLaunchTemplateData +func (mr *MockEC2APIMockRecorder) GetLaunchTemplateData(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateData", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateData), arg0) +} + +// GetLaunchTemplateDataRequest mocks base method +func (m *MockEC2API) GetLaunchTemplateDataRequest(arg0 *ec2.GetLaunchTemplateDataInput) (*request.Request, *ec2.GetLaunchTemplateDataOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLaunchTemplateDataRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetLaunchTemplateDataOutput) + return ret0, ret1 +} + +// GetLaunchTemplateDataRequest indicates an expected call of GetLaunchTemplateDataRequest +func (mr *MockEC2APIMockRecorder) GetLaunchTemplateDataRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateDataRequest), arg0) +} + +// GetLaunchTemplateDataWithContext mocks base method +func (m *MockEC2API) GetLaunchTemplateDataWithContext(arg0 context.Context, arg1 *ec2.GetLaunchTemplateDataInput, arg2 ...request.Option) (*ec2.GetLaunchTemplateDataOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetLaunchTemplateDataWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLaunchTemplateDataWithContext indicates an expected call of GetLaunchTemplateDataWithContext +func (mr *MockEC2APIMockRecorder) GetLaunchTemplateDataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateDataWithContext", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateDataWithContext), varargs...) +} + +// GetManagedPrefixListAssociations mocks base method +func (m *MockEC2API) GetManagedPrefixListAssociations(arg0 *ec2.GetManagedPrefixListAssociationsInput) (*ec2.GetManagedPrefixListAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetManagedPrefixListAssociations", arg0) + ret0, _ := ret[0].(*ec2.GetManagedPrefixListAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetManagedPrefixListAssociations indicates an expected call of GetManagedPrefixListAssociations +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociations", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociations), arg0) +} + +// GetManagedPrefixListAssociationsPages mocks base method +func (m *MockEC2API) GetManagedPrefixListAssociationsPages(arg0 *ec2.GetManagedPrefixListAssociationsInput, arg1 func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetManagedPrefixListAssociationsPages indicates an expected call of GetManagedPrefixListAssociationsPages +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsPages), arg0, arg1) +} + +// GetManagedPrefixListAssociationsPagesWithContext mocks base method +func (m *MockEC2API) GetManagedPrefixListAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListAssociationsInput, arg2 func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetManagedPrefixListAssociationsPagesWithContext indicates an expected call of GetManagedPrefixListAssociationsPagesWithContext +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsPagesWithContext), varargs...) +} + +// GetManagedPrefixListAssociationsRequest mocks base method +func (m *MockEC2API) GetManagedPrefixListAssociationsRequest(arg0 *ec2.GetManagedPrefixListAssociationsInput) (*request.Request, *ec2.GetManagedPrefixListAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetManagedPrefixListAssociationsOutput) + return ret0, ret1 +} + +// GetManagedPrefixListAssociationsRequest indicates an expected call of GetManagedPrefixListAssociationsRequest +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsRequest), arg0) +} + +// GetManagedPrefixListAssociationsWithContext mocks base method +func (m *MockEC2API) GetManagedPrefixListAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListAssociationsInput, arg2 ...request.Option) (*ec2.GetManagedPrefixListAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetManagedPrefixListAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetManagedPrefixListAssociationsWithContext indicates an expected call of GetManagedPrefixListAssociationsWithContext +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListAssociationsWithContext), varargs...) +} + +// GetManagedPrefixListEntries mocks base method +func (m *MockEC2API) GetManagedPrefixListEntries(arg0 *ec2.GetManagedPrefixListEntriesInput) (*ec2.GetManagedPrefixListEntriesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetManagedPrefixListEntries", arg0) + ret0, _ := ret[0].(*ec2.GetManagedPrefixListEntriesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetManagedPrefixListEntries indicates an expected call of GetManagedPrefixListEntries +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntries(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntries", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntries), arg0) +} + +// GetManagedPrefixListEntriesPages mocks base method +func (m *MockEC2API) GetManagedPrefixListEntriesPages(arg0 *ec2.GetManagedPrefixListEntriesInput, arg1 func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetManagedPrefixListEntriesPages indicates an expected call of GetManagedPrefixListEntriesPages +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesPages", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesPages), arg0, arg1) +} + +// GetManagedPrefixListEntriesPagesWithContext mocks base method +func (m *MockEC2API) GetManagedPrefixListEntriesPagesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListEntriesInput, arg2 func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetManagedPrefixListEntriesPagesWithContext indicates an expected call of GetManagedPrefixListEntriesPagesWithContext +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesPagesWithContext), varargs...) +} + +// GetManagedPrefixListEntriesRequest mocks base method +func (m *MockEC2API) GetManagedPrefixListEntriesRequest(arg0 *ec2.GetManagedPrefixListEntriesInput) (*request.Request, *ec2.GetManagedPrefixListEntriesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetManagedPrefixListEntriesOutput) + return ret0, ret1 +} + +// GetManagedPrefixListEntriesRequest indicates an expected call of GetManagedPrefixListEntriesRequest +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesRequest", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesRequest), arg0) +} + +// GetManagedPrefixListEntriesWithContext mocks base method +func (m *MockEC2API) GetManagedPrefixListEntriesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListEntriesInput, arg2 ...request.Option) (*ec2.GetManagedPrefixListEntriesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetManagedPrefixListEntriesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetManagedPrefixListEntriesWithContext indicates an expected call of GetManagedPrefixListEntriesWithContext +func (mr *MockEC2APIMockRecorder) GetManagedPrefixListEntriesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetManagedPrefixListEntriesWithContext), varargs...) +} + +// GetPasswordData mocks base method +func (m *MockEC2API) GetPasswordData(arg0 *ec2.GetPasswordDataInput) (*ec2.GetPasswordDataOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPasswordData", arg0) + ret0, _ := ret[0].(*ec2.GetPasswordDataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPasswordData indicates an expected call of GetPasswordData +func (mr *MockEC2APIMockRecorder) GetPasswordData(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordData", reflect.TypeOf((*MockEC2API)(nil).GetPasswordData), arg0) +} + +// GetPasswordDataRequest mocks base method +func (m *MockEC2API) GetPasswordDataRequest(arg0 *ec2.GetPasswordDataInput) (*request.Request, *ec2.GetPasswordDataOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPasswordDataRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetPasswordDataOutput) + return ret0, ret1 +} + +// GetPasswordDataRequest indicates an expected call of GetPasswordDataRequest +func (mr *MockEC2APIMockRecorder) GetPasswordDataRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetPasswordDataRequest), arg0) +} + +// GetPasswordDataWithContext mocks base method +func (m *MockEC2API) GetPasswordDataWithContext(arg0 context.Context, arg1 *ec2.GetPasswordDataInput, arg2 ...request.Option) (*ec2.GetPasswordDataOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPasswordDataWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetPasswordDataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPasswordDataWithContext indicates an expected call of GetPasswordDataWithContext +func (mr *MockEC2APIMockRecorder) GetPasswordDataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordDataWithContext", reflect.TypeOf((*MockEC2API)(nil).GetPasswordDataWithContext), varargs...) +} + +// GetReservedInstancesExchangeQuote mocks base method +func (m *MockEC2API) GetReservedInstancesExchangeQuote(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuote", arg0) + ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetReservedInstancesExchangeQuote indicates an expected call of GetReservedInstancesExchangeQuote +func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuote), arg0) +} + +// GetReservedInstancesExchangeQuoteRequest mocks base method +func (m *MockEC2API) GetReservedInstancesExchangeQuoteRequest(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.GetReservedInstancesExchangeQuoteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetReservedInstancesExchangeQuoteOutput) + return ret0, ret1 +} + +// GetReservedInstancesExchangeQuoteRequest indicates an expected call of GetReservedInstancesExchangeQuoteRequest +func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteRequest), arg0) +} + +// GetReservedInstancesExchangeQuoteWithContext mocks base method +func (m *MockEC2API) GetReservedInstancesExchangeQuoteWithContext(arg0 context.Context, arg1 *ec2.GetReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetReservedInstancesExchangeQuoteWithContext indicates an expected call of GetReservedInstancesExchangeQuoteWithContext +func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteWithContext), varargs...) +} + +// GetTransitGatewayAttachmentPropagations mocks base method +func (m *MockEC2API) GetTransitGatewayAttachmentPropagations(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagations", arg0) + ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayAttachmentPropagations indicates an expected call of GetTransitGatewayAttachmentPropagations +func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagations), arg0) +} + +// GetTransitGatewayAttachmentPropagationsPages mocks base method +func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPages(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg1 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayAttachmentPropagationsPages indicates an expected call of GetTransitGatewayAttachmentPropagationsPages +func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPages), arg0, arg1) +} + +// GetTransitGatewayAttachmentPropagationsPagesWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayAttachmentPropagationsPagesWithContext indicates an expected call of GetTransitGatewayAttachmentPropagationsPagesWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPagesWithContext), varargs...) +} + +// GetTransitGatewayAttachmentPropagationsRequest mocks base method +func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsRequest(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*request.Request, *ec2.GetTransitGatewayAttachmentPropagationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) + return ret0, ret1 +} + +// GetTransitGatewayAttachmentPropagationsRequest indicates an expected call of GetTransitGatewayAttachmentPropagationsRequest +func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsRequest), arg0) +} + +// GetTransitGatewayAttachmentPropagationsWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayAttachmentPropagationsWithContext indicates an expected call of GetTransitGatewayAttachmentPropagationsWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsWithContext), varargs...) +} + +// GetTransitGatewayMulticastDomainAssociations mocks base method +func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociations(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociations", arg0) + ret0, _ := ret[0].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayMulticastDomainAssociations indicates an expected call of GetTransitGatewayMulticastDomainAssociations +func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociations), arg0) +} + +// GetTransitGatewayMulticastDomainAssociationsPages mocks base method +func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsPages(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg1 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayMulticastDomainAssociationsPages indicates an expected call of GetTransitGatewayMulticastDomainAssociationsPages +func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsPages), arg0, arg1) +} + +// GetTransitGatewayMulticastDomainAssociationsPagesWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg2 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayMulticastDomainAssociationsPagesWithContext indicates an expected call of GetTransitGatewayMulticastDomainAssociationsPagesWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsPagesWithContext), varargs...) +} + +// GetTransitGatewayMulticastDomainAssociationsRequest mocks base method +func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.GetTransitGatewayMulticastDomainAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput) + return ret0, ret1 +} + +// GetTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of GetTransitGatewayMulticastDomainAssociationsRequest +func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsRequest), arg0) +} + +// GetTransitGatewayMulticastDomainAssociationsWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayMulticastDomainAssociationsWithContext indicates an expected call of GetTransitGatewayMulticastDomainAssociationsWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsWithContext), varargs...) +} + +// GetTransitGatewayPrefixListReferences mocks base method +func (m *MockEC2API) GetTransitGatewayPrefixListReferences(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferences", arg0) + ret0, _ := ret[0].(*ec2.GetTransitGatewayPrefixListReferencesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayPrefixListReferences indicates an expected call of GetTransitGatewayPrefixListReferences +func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferences(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferences", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferences), arg0) +} + +// GetTransitGatewayPrefixListReferencesPages mocks base method +func (m *MockEC2API) GetTransitGatewayPrefixListReferencesPages(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput, arg1 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayPrefixListReferencesPages indicates an expected call of GetTransitGatewayPrefixListReferencesPages +func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesPages), arg0, arg1) +} + +// GetTransitGatewayPrefixListReferencesPagesWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayPrefixListReferencesPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPrefixListReferencesInput, arg2 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayPrefixListReferencesPagesWithContext indicates an expected call of GetTransitGatewayPrefixListReferencesPagesWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesPagesWithContext), varargs...) +} + +// GetTransitGatewayPrefixListReferencesRequest mocks base method +func (m *MockEC2API) GetTransitGatewayPrefixListReferencesRequest(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*request.Request, *ec2.GetTransitGatewayPrefixListReferencesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetTransitGatewayPrefixListReferencesOutput) + return ret0, ret1 +} + +// GetTransitGatewayPrefixListReferencesRequest indicates an expected call of GetTransitGatewayPrefixListReferencesRequest +func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesRequest), arg0) +} + +// GetTransitGatewayPrefixListReferencesWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayPrefixListReferencesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPrefixListReferencesInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetTransitGatewayPrefixListReferencesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayPrefixListReferencesWithContext indicates an expected call of GetTransitGatewayPrefixListReferencesWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayPrefixListReferencesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayPrefixListReferencesWithContext), varargs...) +} + +// GetTransitGatewayRouteTableAssociations mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTableAssociations(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociations", arg0) + ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayRouteTableAssociations indicates an expected call of GetTransitGatewayRouteTableAssociations +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociations), arg0) +} + +// GetTransitGatewayRouteTableAssociationsPages mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPages(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg1 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayRouteTableAssociationsPages indicates an expected call of GetTransitGatewayRouteTableAssociationsPages +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPages), arg0, arg1) +} + +// GetTransitGatewayRouteTableAssociationsPagesWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayRouteTableAssociationsPagesWithContext indicates an expected call of GetTransitGatewayRouteTableAssociationsPagesWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPagesWithContext), varargs...) +} + +// GetTransitGatewayRouteTableAssociationsRequest mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsRequest(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTableAssociationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) + return ret0, ret1 +} + +// GetTransitGatewayRouteTableAssociationsRequest indicates an expected call of GetTransitGatewayRouteTableAssociationsRequest +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsRequest), arg0) +} + +// GetTransitGatewayRouteTableAssociationsWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayRouteTableAssociationsWithContext indicates an expected call of GetTransitGatewayRouteTableAssociationsWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsWithContext), varargs...) +} + +// GetTransitGatewayRouteTablePropagations mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTablePropagations(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagations", arg0) + ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayRouteTablePropagations indicates an expected call of GetTransitGatewayRouteTablePropagations +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagations), arg0) +} + +// GetTransitGatewayRouteTablePropagationsPages mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPages(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg1 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayRouteTablePropagationsPages indicates an expected call of GetTransitGatewayRouteTablePropagationsPages +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPages), arg0, arg1) +} + +// GetTransitGatewayRouteTablePropagationsPagesWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetTransitGatewayRouteTablePropagationsPagesWithContext indicates an expected call of GetTransitGatewayRouteTablePropagationsPagesWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPagesWithContext), varargs...) +} + +// GetTransitGatewayRouteTablePropagationsRequest mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsRequest(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTablePropagationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) + return ret0, ret1 +} + +// GetTransitGatewayRouteTablePropagationsRequest indicates an expected call of GetTransitGatewayRouteTablePropagationsRequest +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsRequest), arg0) +} + +// GetTransitGatewayRouteTablePropagationsWithContext mocks base method +func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTransitGatewayRouteTablePropagationsWithContext indicates an expected call of GetTransitGatewayRouteTablePropagationsWithContext +func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsWithContext), varargs...) +} + +// ImportClientVpnClientCertificateRevocationList mocks base method +func (m *MockEC2API) ImportClientVpnClientCertificateRevocationList(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationList", arg0) + ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportClientVpnClientCertificateRevocationList indicates an expected call of ImportClientVpnClientCertificateRevocationList +func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationList), arg0) +} + +// ImportClientVpnClientCertificateRevocationListRequest mocks base method +func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ImportClientVpnClientCertificateRevocationListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) + return ret0, ret1 +} + +// ImportClientVpnClientCertificateRevocationListRequest indicates an expected call of ImportClientVpnClientCertificateRevocationListRequest +func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListRequest), arg0) +} + +// ImportClientVpnClientCertificateRevocationListWithContext mocks base method +func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListWithContext(arg0 context.Context, arg1 *ec2.ImportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportClientVpnClientCertificateRevocationListWithContext indicates an expected call of ImportClientVpnClientCertificateRevocationListWithContext +func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationListWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListWithContext), varargs...) +} + +// ImportImage mocks base method +func (m *MockEC2API) ImportImage(arg0 *ec2.ImportImageInput) (*ec2.ImportImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportImage", arg0) + ret0, _ := ret[0].(*ec2.ImportImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportImage indicates an expected call of ImportImage +func (mr *MockEC2APIMockRecorder) ImportImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImage", reflect.TypeOf((*MockEC2API)(nil).ImportImage), arg0) +} + +// ImportImageRequest mocks base method +func (m *MockEC2API) ImportImageRequest(arg0 *ec2.ImportImageInput) (*request.Request, *ec2.ImportImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ImportImageOutput) + return ret0, ret1 +} + +// ImportImageRequest indicates an expected call of ImportImageRequest +func (mr *MockEC2APIMockRecorder) ImportImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ImportImageRequest), arg0) +} + +// ImportImageWithContext mocks base method +func (m *MockEC2API) ImportImageWithContext(arg0 context.Context, arg1 *ec2.ImportImageInput, arg2 ...request.Option) (*ec2.ImportImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ImportImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportImageWithContext indicates an expected call of ImportImageWithContext +func (mr *MockEC2APIMockRecorder) ImportImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImageWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportImageWithContext), varargs...) +} + +// ImportInstance mocks base method +func (m *MockEC2API) ImportInstance(arg0 *ec2.ImportInstanceInput) (*ec2.ImportInstanceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportInstance", arg0) + ret0, _ := ret[0].(*ec2.ImportInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportInstance indicates an expected call of ImportInstance +func (mr *MockEC2APIMockRecorder) ImportInstance(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstance", reflect.TypeOf((*MockEC2API)(nil).ImportInstance), arg0) +} + +// ImportInstanceRequest mocks base method +func (m *MockEC2API) ImportInstanceRequest(arg0 *ec2.ImportInstanceInput) (*request.Request, *ec2.ImportInstanceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportInstanceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ImportInstanceOutput) + return ret0, ret1 +} + +// ImportInstanceRequest indicates an expected call of ImportInstanceRequest +func (mr *MockEC2APIMockRecorder) ImportInstanceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ImportInstanceRequest), arg0) +} + +// ImportInstanceWithContext mocks base method +func (m *MockEC2API) ImportInstanceWithContext(arg0 context.Context, arg1 *ec2.ImportInstanceInput, arg2 ...request.Option) (*ec2.ImportInstanceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportInstanceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ImportInstanceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportInstanceWithContext indicates an expected call of ImportInstanceWithContext +func (mr *MockEC2APIMockRecorder) ImportInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportInstanceWithContext), varargs...) +} + +// ImportKeyPair mocks base method +func (m *MockEC2API) ImportKeyPair(arg0 *ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportKeyPair", arg0) + ret0, _ := ret[0].(*ec2.ImportKeyPairOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportKeyPair indicates an expected call of ImportKeyPair +func (mr *MockEC2APIMockRecorder) ImportKeyPair(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPair", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPair), arg0) +} + +// ImportKeyPairRequest mocks base method +func (m *MockEC2API) ImportKeyPairRequest(arg0 *ec2.ImportKeyPairInput) (*request.Request, *ec2.ImportKeyPairOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportKeyPairRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ImportKeyPairOutput) + return ret0, ret1 +} + +// ImportKeyPairRequest indicates an expected call of ImportKeyPairRequest +func (mr *MockEC2APIMockRecorder) ImportKeyPairRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPairRequest), arg0) +} + +// ImportKeyPairWithContext mocks base method +func (m *MockEC2API) ImportKeyPairWithContext(arg0 context.Context, arg1 *ec2.ImportKeyPairInput, arg2 ...request.Option) (*ec2.ImportKeyPairOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportKeyPairWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ImportKeyPairOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportKeyPairWithContext indicates an expected call of ImportKeyPairWithContext +func (mr *MockEC2APIMockRecorder) ImportKeyPairWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPairWithContext), varargs...) +} + +// ImportSnapshot mocks base method +func (m *MockEC2API) ImportSnapshot(arg0 *ec2.ImportSnapshotInput) (*ec2.ImportSnapshotOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportSnapshot", arg0) + ret0, _ := ret[0].(*ec2.ImportSnapshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportSnapshot indicates an expected call of ImportSnapshot +func (mr *MockEC2APIMockRecorder) ImportSnapshot(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshot", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshot), arg0) +} + +// ImportSnapshotRequest mocks base method +func (m *MockEC2API) ImportSnapshotRequest(arg0 *ec2.ImportSnapshotInput) (*request.Request, *ec2.ImportSnapshotOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportSnapshotRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ImportSnapshotOutput) + return ret0, ret1 +} + +// ImportSnapshotRequest indicates an expected call of ImportSnapshotRequest +func (mr *MockEC2APIMockRecorder) ImportSnapshotRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshotRequest), arg0) +} + +// ImportSnapshotWithContext mocks base method +func (m *MockEC2API) ImportSnapshotWithContext(arg0 context.Context, arg1 *ec2.ImportSnapshotInput, arg2 ...request.Option) (*ec2.ImportSnapshotOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportSnapshotWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ImportSnapshotOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportSnapshotWithContext indicates an expected call of ImportSnapshotWithContext +func (mr *MockEC2APIMockRecorder) ImportSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshotWithContext), varargs...) +} + +// ImportVolume mocks base method +func (m *MockEC2API) ImportVolume(arg0 *ec2.ImportVolumeInput) (*ec2.ImportVolumeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportVolume", arg0) + ret0, _ := ret[0].(*ec2.ImportVolumeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportVolume indicates an expected call of ImportVolume +func (mr *MockEC2APIMockRecorder) ImportVolume(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolume", reflect.TypeOf((*MockEC2API)(nil).ImportVolume), arg0) +} + +// ImportVolumeRequest mocks base method +func (m *MockEC2API) ImportVolumeRequest(arg0 *ec2.ImportVolumeInput) (*request.Request, *ec2.ImportVolumeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportVolumeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ImportVolumeOutput) + return ret0, ret1 +} + +// ImportVolumeRequest indicates an expected call of ImportVolumeRequest +func (mr *MockEC2APIMockRecorder) ImportVolumeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeRequest), arg0) +} + +// ImportVolumeWithContext mocks base method +func (m *MockEC2API) ImportVolumeWithContext(arg0 context.Context, arg1 *ec2.ImportVolumeInput, arg2 ...request.Option) (*ec2.ImportVolumeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportVolumeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ImportVolumeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportVolumeWithContext indicates an expected call of ImportVolumeWithContext +func (mr *MockEC2APIMockRecorder) ImportVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeWithContext), varargs...) +} + +// ModifyAvailabilityZoneGroup mocks base method +func (m *MockEC2API) ModifyAvailabilityZoneGroup(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*ec2.ModifyAvailabilityZoneGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroup", arg0) + ret0, _ := ret[0].(*ec2.ModifyAvailabilityZoneGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyAvailabilityZoneGroup indicates an expected call of ModifyAvailabilityZoneGroup +func (mr *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroup", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroup), arg0) +} + +// ModifyAvailabilityZoneGroupRequest mocks base method +func (m *MockEC2API) ModifyAvailabilityZoneGroupRequest(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*request.Request, *ec2.ModifyAvailabilityZoneGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyAvailabilityZoneGroupOutput) + return ret0, ret1 +} + +// ModifyAvailabilityZoneGroupRequest indicates an expected call of ModifyAvailabilityZoneGroupRequest +func (mr *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroupRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroupRequest), arg0) +} + +// ModifyAvailabilityZoneGroupWithContext mocks base method +func (m *MockEC2API) ModifyAvailabilityZoneGroupWithContext(arg0 context.Context, arg1 *ec2.ModifyAvailabilityZoneGroupInput, arg2 ...request.Option) (*ec2.ModifyAvailabilityZoneGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroupWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyAvailabilityZoneGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyAvailabilityZoneGroupWithContext indicates an expected call of ModifyAvailabilityZoneGroupWithContext +func (mr *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroupWithContext), varargs...) +} + +// ModifyCapacityReservation mocks base method +func (m *MockEC2API) ModifyCapacityReservation(arg0 *ec2.ModifyCapacityReservationInput) (*ec2.ModifyCapacityReservationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyCapacityReservation", arg0) + ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyCapacityReservation indicates an expected call of ModifyCapacityReservation +func (mr *MockEC2APIMockRecorder) ModifyCapacityReservation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservation), arg0) +} + +// ModifyCapacityReservationRequest mocks base method +func (m *MockEC2API) ModifyCapacityReservationRequest(arg0 *ec2.ModifyCapacityReservationInput) (*request.Request, *ec2.ModifyCapacityReservationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyCapacityReservationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyCapacityReservationOutput) + return ret0, ret1 +} + +// ModifyCapacityReservationRequest indicates an expected call of ModifyCapacityReservationRequest +func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationRequest), arg0) +} + +// ModifyCapacityReservationWithContext mocks base method +func (m *MockEC2API) ModifyCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.ModifyCapacityReservationInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyCapacityReservationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyCapacityReservationWithContext indicates an expected call of ModifyCapacityReservationWithContext +func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationWithContext), varargs...) +} + +// ModifyClientVpnEndpoint mocks base method +func (m *MockEC2API) ModifyClientVpnEndpoint(arg0 *ec2.ModifyClientVpnEndpointInput) (*ec2.ModifyClientVpnEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyClientVpnEndpoint", arg0) + ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyClientVpnEndpoint indicates an expected call of ModifyClientVpnEndpoint +func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpoint), arg0) +} + +// ModifyClientVpnEndpointRequest mocks base method +func (m *MockEC2API) ModifyClientVpnEndpointRequest(arg0 *ec2.ModifyClientVpnEndpointInput) (*request.Request, *ec2.ModifyClientVpnEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyClientVpnEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyClientVpnEndpointOutput) + return ret0, ret1 +} + +// ModifyClientVpnEndpointRequest indicates an expected call of ModifyClientVpnEndpointRequest +func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointRequest), arg0) +} + +// ModifyClientVpnEndpointWithContext mocks base method +func (m *MockEC2API) ModifyClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyClientVpnEndpointInput, arg2 ...request.Option) (*ec2.ModifyClientVpnEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyClientVpnEndpointWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyClientVpnEndpointWithContext indicates an expected call of ModifyClientVpnEndpointWithContext +func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointWithContext), varargs...) +} + +// ModifyDefaultCreditSpecification mocks base method +func (m *MockEC2API) ModifyDefaultCreditSpecification(arg0 *ec2.ModifyDefaultCreditSpecificationInput) (*ec2.ModifyDefaultCreditSpecificationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecification", arg0) + ret0, _ := ret[0].(*ec2.ModifyDefaultCreditSpecificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyDefaultCreditSpecification indicates an expected call of ModifyDefaultCreditSpecification +func (mr *MockEC2APIMockRecorder) ModifyDefaultCreditSpecification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecification), arg0) +} + +// ModifyDefaultCreditSpecificationRequest mocks base method +func (m *MockEC2API) ModifyDefaultCreditSpecificationRequest(arg0 *ec2.ModifyDefaultCreditSpecificationInput) (*request.Request, *ec2.ModifyDefaultCreditSpecificationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyDefaultCreditSpecificationOutput) + return ret0, ret1 +} + +// ModifyDefaultCreditSpecificationRequest indicates an expected call of ModifyDefaultCreditSpecificationRequest +func (mr *MockEC2APIMockRecorder) ModifyDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecificationRequest), arg0) +} + +// ModifyDefaultCreditSpecificationWithContext mocks base method +func (m *MockEC2API) ModifyDefaultCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.ModifyDefaultCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyDefaultCreditSpecificationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecificationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyDefaultCreditSpecificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyDefaultCreditSpecificationWithContext indicates an expected call of ModifyDefaultCreditSpecificationWithContext +func (mr *MockEC2APIMockRecorder) ModifyDefaultCreditSpecificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecificationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecificationWithContext), varargs...) +} + +// ModifyEbsDefaultKmsKeyId mocks base method +func (m *MockEC2API) ModifyEbsDefaultKmsKeyId(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyId", arg0) + ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyEbsDefaultKmsKeyId indicates an expected call of ModifyEbsDefaultKmsKeyId +func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyId), arg0) +} + +// ModifyEbsDefaultKmsKeyIdRequest mocks base method +func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdRequest(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ModifyEbsDefaultKmsKeyIdOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) + return ret0, ret1 +} + +// ModifyEbsDefaultKmsKeyIdRequest indicates an expected call of ModifyEbsDefaultKmsKeyIdRequest +func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdRequest), arg0) +} + +// ModifyEbsDefaultKmsKeyIdWithContext mocks base method +func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.ModifyEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyEbsDefaultKmsKeyIdWithContext indicates an expected call of ModifyEbsDefaultKmsKeyIdWithContext +func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdWithContext), varargs...) +} + +// ModifyFleet mocks base method +func (m *MockEC2API) ModifyFleet(arg0 *ec2.ModifyFleetInput) (*ec2.ModifyFleetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyFleet", arg0) + ret0, _ := ret[0].(*ec2.ModifyFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyFleet indicates an expected call of ModifyFleet +func (mr *MockEC2APIMockRecorder) ModifyFleet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleet", reflect.TypeOf((*MockEC2API)(nil).ModifyFleet), arg0) +} + +// ModifyFleetRequest mocks base method +func (m *MockEC2API) ModifyFleetRequest(arg0 *ec2.ModifyFleetInput) (*request.Request, *ec2.ModifyFleetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyFleetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyFleetOutput) + return ret0, ret1 +} + +// ModifyFleetRequest indicates an expected call of ModifyFleetRequest +func (mr *MockEC2APIMockRecorder) ModifyFleetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFleetRequest), arg0) +} + +// ModifyFleetWithContext mocks base method +func (m *MockEC2API) ModifyFleetWithContext(arg0 context.Context, arg1 *ec2.ModifyFleetInput, arg2 ...request.Option) (*ec2.ModifyFleetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyFleetWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyFleetWithContext indicates an expected call of ModifyFleetWithContext +func (mr *MockEC2APIMockRecorder) ModifyFleetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyFleetWithContext), varargs...) +} + +// ModifyFpgaImageAttribute mocks base method +func (m *MockEC2API) ModifyFpgaImageAttribute(arg0 *ec2.ModifyFpgaImageAttributeInput) (*ec2.ModifyFpgaImageAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyFpgaImageAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyFpgaImageAttribute indicates an expected call of ModifyFpgaImageAttribute +func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttribute), arg0) +} + +// ModifyFpgaImageAttributeRequest mocks base method +func (m *MockEC2API) ModifyFpgaImageAttributeRequest(arg0 *ec2.ModifyFpgaImageAttributeInput) (*request.Request, *ec2.ModifyFpgaImageAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyFpgaImageAttributeOutput) + return ret0, ret1 +} + +// ModifyFpgaImageAttributeRequest indicates an expected call of ModifyFpgaImageAttributeRequest +func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttributeRequest), arg0) +} + +// ModifyFpgaImageAttributeWithContext mocks base method +func (m *MockEC2API) ModifyFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyFpgaImageAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyFpgaImageAttributeWithContext indicates an expected call of ModifyFpgaImageAttributeWithContext +func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttributeWithContext), varargs...) +} + +// ModifyHosts mocks base method +func (m *MockEC2API) ModifyHosts(arg0 *ec2.ModifyHostsInput) (*ec2.ModifyHostsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyHosts", arg0) + ret0, _ := ret[0].(*ec2.ModifyHostsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyHosts indicates an expected call of ModifyHosts +func (mr *MockEC2APIMockRecorder) ModifyHosts(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHosts", reflect.TypeOf((*MockEC2API)(nil).ModifyHosts), arg0) +} + +// ModifyHostsRequest mocks base method +func (m *MockEC2API) ModifyHostsRequest(arg0 *ec2.ModifyHostsInput) (*request.Request, *ec2.ModifyHostsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyHostsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyHostsOutput) + return ret0, ret1 +} + +// ModifyHostsRequest indicates an expected call of ModifyHostsRequest +func (mr *MockEC2APIMockRecorder) ModifyHostsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyHostsRequest), arg0) +} + +// ModifyHostsWithContext mocks base method +func (m *MockEC2API) ModifyHostsWithContext(arg0 context.Context, arg1 *ec2.ModifyHostsInput, arg2 ...request.Option) (*ec2.ModifyHostsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyHostsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyHostsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyHostsWithContext indicates an expected call of ModifyHostsWithContext +func (mr *MockEC2APIMockRecorder) ModifyHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyHostsWithContext), varargs...) +} + +// ModifyIdFormat mocks base method +func (m *MockEC2API) ModifyIdFormat(arg0 *ec2.ModifyIdFormatInput) (*ec2.ModifyIdFormatOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyIdFormat", arg0) + ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyIdFormat indicates an expected call of ModifyIdFormat +func (mr *MockEC2APIMockRecorder) ModifyIdFormat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormat), arg0) +} + +// ModifyIdFormatRequest mocks base method +func (m *MockEC2API) ModifyIdFormatRequest(arg0 *ec2.ModifyIdFormatInput) (*request.Request, *ec2.ModifyIdFormatOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyIdFormatRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyIdFormatOutput) + return ret0, ret1 +} + +// ModifyIdFormatRequest indicates an expected call of ModifyIdFormatRequest +func (mr *MockEC2APIMockRecorder) ModifyIdFormatRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormatRequest), arg0) +} + +// ModifyIdFormatWithContext mocks base method +func (m *MockEC2API) ModifyIdFormatWithContext(arg0 context.Context, arg1 *ec2.ModifyIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdFormatOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyIdFormatWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyIdFormatWithContext indicates an expected call of ModifyIdFormatWithContext +func (mr *MockEC2APIMockRecorder) ModifyIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormatWithContext), varargs...) +} + +// ModifyIdentityIdFormat mocks base method +func (m *MockEC2API) ModifyIdentityIdFormat(arg0 *ec2.ModifyIdentityIdFormatInput) (*ec2.ModifyIdentityIdFormatOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyIdentityIdFormat", arg0) + ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyIdentityIdFormat indicates an expected call of ModifyIdentityIdFormat +func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormat), arg0) +} + +// ModifyIdentityIdFormatRequest mocks base method +func (m *MockEC2API) ModifyIdentityIdFormatRequest(arg0 *ec2.ModifyIdentityIdFormatInput) (*request.Request, *ec2.ModifyIdentityIdFormatOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyIdentityIdFormatRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyIdentityIdFormatOutput) + return ret0, ret1 +} + +// ModifyIdentityIdFormatRequest indicates an expected call of ModifyIdentityIdFormatRequest +func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormatRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormatRequest), arg0) +} + +// ModifyIdentityIdFormatWithContext mocks base method +func (m *MockEC2API) ModifyIdentityIdFormatWithContext(arg0 context.Context, arg1 *ec2.ModifyIdentityIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdentityIdFormatOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyIdentityIdFormatWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyIdentityIdFormatWithContext indicates an expected call of ModifyIdentityIdFormatWithContext +func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormatWithContext), varargs...) +} + +// ModifyImageAttribute mocks base method +func (m *MockEC2API) ModifyImageAttribute(arg0 *ec2.ModifyImageAttributeInput) (*ec2.ModifyImageAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyImageAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyImageAttribute indicates an expected call of ModifyImageAttribute +func (mr *MockEC2APIMockRecorder) ModifyImageAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttribute), arg0) +} + +// ModifyImageAttributeRequest mocks base method +func (m *MockEC2API) ModifyImageAttributeRequest(arg0 *ec2.ModifyImageAttributeInput) (*request.Request, *ec2.ModifyImageAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyImageAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyImageAttributeOutput) + return ret0, ret1 +} + +// ModifyImageAttributeRequest indicates an expected call of ModifyImageAttributeRequest +func (mr *MockEC2APIMockRecorder) ModifyImageAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttributeRequest), arg0) +} + +// ModifyImageAttributeWithContext mocks base method +func (m *MockEC2API) ModifyImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyImageAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyImageAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyImageAttributeWithContext indicates an expected call of ModifyImageAttributeWithContext +func (mr *MockEC2APIMockRecorder) ModifyImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttributeWithContext), varargs...) +} + +// ModifyInstanceAttribute mocks base method +func (m *MockEC2API) ModifyInstanceAttribute(arg0 *ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceAttribute indicates an expected call of ModifyInstanceAttribute +func (mr *MockEC2APIMockRecorder) ModifyInstanceAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttribute), arg0) +} + +// ModifyInstanceAttributeRequest mocks base method +func (m *MockEC2API) ModifyInstanceAttributeRequest(arg0 *ec2.ModifyInstanceAttributeInput) (*request.Request, *ec2.ModifyInstanceAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyInstanceAttributeOutput) + return ret0, ret1 +} + +// ModifyInstanceAttributeRequest indicates an expected call of ModifyInstanceAttributeRequest +func (mr *MockEC2APIMockRecorder) ModifyInstanceAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttributeRequest), arg0) +} + +// ModifyInstanceAttributeWithContext mocks base method +func (m *MockEC2API) ModifyInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceAttributeInput, arg2 ...request.Option) (*ec2.ModifyInstanceAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyInstanceAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceAttributeWithContext indicates an expected call of ModifyInstanceAttributeWithContext +func (mr *MockEC2APIMockRecorder) ModifyInstanceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttributeWithContext), varargs...) +} + +// ModifyInstanceCapacityReservationAttributes mocks base method +func (m *MockEC2API) ModifyInstanceCapacityReservationAttributes(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributes", arg0) + ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceCapacityReservationAttributes indicates an expected call of ModifyInstanceCapacityReservationAttributes +func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributes", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributes), arg0) +} + +// ModifyInstanceCapacityReservationAttributesRequest mocks base method +func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesRequest(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*request.Request, *ec2.ModifyInstanceCapacityReservationAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) + return ret0, ret1 +} + +// ModifyInstanceCapacityReservationAttributesRequest indicates an expected call of ModifyInstanceCapacityReservationAttributesRequest +func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesRequest), arg0) +} + +// ModifyInstanceCapacityReservationAttributesWithContext mocks base method +func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceCapacityReservationAttributesInput, arg2 ...request.Option) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceCapacityReservationAttributesWithContext indicates an expected call of ModifyInstanceCapacityReservationAttributesWithContext +func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesWithContext), varargs...) +} + +// ModifyInstanceCreditSpecification mocks base method +func (m *MockEC2API) ModifyInstanceCreditSpecification(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*ec2.ModifyInstanceCreditSpecificationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecification", arg0) + ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceCreditSpecification indicates an expected call of ModifyInstanceCreditSpecification +func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecification), arg0) +} + +// ModifyInstanceCreditSpecificationRequest mocks base method +func (m *MockEC2API) ModifyInstanceCreditSpecificationRequest(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*request.Request, *ec2.ModifyInstanceCreditSpecificationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyInstanceCreditSpecificationOutput) + return ret0, ret1 +} + +// ModifyInstanceCreditSpecificationRequest indicates an expected call of ModifyInstanceCreditSpecificationRequest +func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecificationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecificationRequest), arg0) +} + +// ModifyInstanceCreditSpecificationWithContext mocks base method +func (m *MockEC2API) ModifyInstanceCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyInstanceCreditSpecificationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceCreditSpecificationWithContext indicates an expected call of ModifyInstanceCreditSpecificationWithContext +func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecificationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecificationWithContext), varargs...) +} + +// ModifyInstanceEventStartTime mocks base method +func (m *MockEC2API) ModifyInstanceEventStartTime(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*ec2.ModifyInstanceEventStartTimeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceEventStartTime", arg0) + ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceEventStartTime indicates an expected call of ModifyInstanceEventStartTime +func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTime(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTime", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTime), arg0) +} + +// ModifyInstanceEventStartTimeRequest mocks base method +func (m *MockEC2API) ModifyInstanceEventStartTimeRequest(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*request.Request, *ec2.ModifyInstanceEventStartTimeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyInstanceEventStartTimeOutput) + return ret0, ret1 +} + +// ModifyInstanceEventStartTimeRequest indicates an expected call of ModifyInstanceEventStartTimeRequest +func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTimeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTimeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTimeRequest), arg0) +} + +// ModifyInstanceEventStartTimeWithContext mocks base method +func (m *MockEC2API) ModifyInstanceEventStartTimeWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceEventStartTimeInput, arg2 ...request.Option) (*ec2.ModifyInstanceEventStartTimeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceEventStartTimeWithContext indicates an expected call of ModifyInstanceEventStartTimeWithContext +func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTimeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTimeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTimeWithContext), varargs...) +} + +// ModifyInstanceMetadataOptions mocks base method +func (m *MockEC2API) ModifyInstanceMetadataOptions(arg0 *ec2.ModifyInstanceMetadataOptionsInput) (*ec2.ModifyInstanceMetadataOptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptions", arg0) + ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceMetadataOptions indicates an expected call of ModifyInstanceMetadataOptions +func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptions), arg0) +} + +// ModifyInstanceMetadataOptionsRequest mocks base method +func (m *MockEC2API) ModifyInstanceMetadataOptionsRequest(arg0 *ec2.ModifyInstanceMetadataOptionsInput) (*request.Request, *ec2.ModifyInstanceMetadataOptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyInstanceMetadataOptionsOutput) + return ret0, ret1 +} + +// ModifyInstanceMetadataOptionsRequest indicates an expected call of ModifyInstanceMetadataOptionsRequest +func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptionsRequest), arg0) +} + +// ModifyInstanceMetadataOptionsWithContext mocks base method +func (m *MockEC2API) ModifyInstanceMetadataOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMetadataOptionsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMetadataOptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstanceMetadataOptionsWithContext indicates an expected call of ModifyInstanceMetadataOptionsWithContext +func (mr *MockEC2APIMockRecorder) ModifyInstanceMetadataOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptionsWithContext), varargs...) +} + +// ModifyInstancePlacement mocks base method +func (m *MockEC2API) ModifyInstancePlacement(arg0 *ec2.ModifyInstancePlacementInput) (*ec2.ModifyInstancePlacementOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstancePlacement", arg0) + ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstancePlacement indicates an expected call of ModifyInstancePlacement +func (mr *MockEC2APIMockRecorder) ModifyInstancePlacement(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacement", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacement), arg0) +} + +// ModifyInstancePlacementRequest mocks base method +func (m *MockEC2API) ModifyInstancePlacementRequest(arg0 *ec2.ModifyInstancePlacementInput) (*request.Request, *ec2.ModifyInstancePlacementOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyInstancePlacementRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyInstancePlacementOutput) + return ret0, ret1 +} + +// ModifyInstancePlacementRequest indicates an expected call of ModifyInstancePlacementRequest +func (mr *MockEC2APIMockRecorder) ModifyInstancePlacementRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacementRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacementRequest), arg0) +} + +// ModifyInstancePlacementWithContext mocks base method +func (m *MockEC2API) ModifyInstancePlacementWithContext(arg0 context.Context, arg1 *ec2.ModifyInstancePlacementInput, arg2 ...request.Option) (*ec2.ModifyInstancePlacementOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyInstancePlacementWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyInstancePlacementWithContext indicates an expected call of ModifyInstancePlacementWithContext +func (mr *MockEC2APIMockRecorder) ModifyInstancePlacementWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacementWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacementWithContext), varargs...) +} + +// ModifyLaunchTemplate mocks base method +func (m *MockEC2API) ModifyLaunchTemplate(arg0 *ec2.ModifyLaunchTemplateInput) (*ec2.ModifyLaunchTemplateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyLaunchTemplate", arg0) + ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyLaunchTemplate indicates an expected call of ModifyLaunchTemplate +func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplate), arg0) +} + +// ModifyLaunchTemplateRequest mocks base method +func (m *MockEC2API) ModifyLaunchTemplateRequest(arg0 *ec2.ModifyLaunchTemplateInput) (*request.Request, *ec2.ModifyLaunchTemplateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyLaunchTemplateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyLaunchTemplateOutput) + return ret0, ret1 +} + +// ModifyLaunchTemplateRequest indicates an expected call of ModifyLaunchTemplateRequest +func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplateRequest), arg0) +} + +// ModifyLaunchTemplateWithContext mocks base method +func (m *MockEC2API) ModifyLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.ModifyLaunchTemplateInput, arg2 ...request.Option) (*ec2.ModifyLaunchTemplateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyLaunchTemplateWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyLaunchTemplateWithContext indicates an expected call of ModifyLaunchTemplateWithContext +func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplateWithContext), varargs...) +} + +// ModifyManagedPrefixList mocks base method +func (m *MockEC2API) ModifyManagedPrefixList(arg0 *ec2.ModifyManagedPrefixListInput) (*ec2.ModifyManagedPrefixListOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyManagedPrefixList", arg0) + ret0, _ := ret[0].(*ec2.ModifyManagedPrefixListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyManagedPrefixList indicates an expected call of ModifyManagedPrefixList +func (mr *MockEC2APIMockRecorder) ModifyManagedPrefixList(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixList", reflect.TypeOf((*MockEC2API)(nil).ModifyManagedPrefixList), arg0) +} + +// ModifyManagedPrefixListRequest mocks base method +func (m *MockEC2API) ModifyManagedPrefixListRequest(arg0 *ec2.ModifyManagedPrefixListInput) (*request.Request, *ec2.ModifyManagedPrefixListOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyManagedPrefixListRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyManagedPrefixListOutput) + return ret0, ret1 +} + +// ModifyManagedPrefixListRequest indicates an expected call of ModifyManagedPrefixListRequest +func (mr *MockEC2APIMockRecorder) ModifyManagedPrefixListRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixListRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyManagedPrefixListRequest), arg0) +} + +// ModifyManagedPrefixListWithContext mocks base method +func (m *MockEC2API) ModifyManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.ModifyManagedPrefixListInput, arg2 ...request.Option) (*ec2.ModifyManagedPrefixListOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyManagedPrefixListWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyManagedPrefixListOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyManagedPrefixListWithContext indicates an expected call of ModifyManagedPrefixListWithContext +func (mr *MockEC2APIMockRecorder) ModifyManagedPrefixListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixListWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyManagedPrefixListWithContext), varargs...) +} + +// ModifyNetworkInterfaceAttribute mocks base method +func (m *MockEC2API) ModifyNetworkInterfaceAttribute(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyNetworkInterfaceAttribute indicates an expected call of ModifyNetworkInterfaceAttribute +func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttribute), arg0) +} + +// ModifyNetworkInterfaceAttributeRequest mocks base method +func (m *MockEC2API) ModifyNetworkInterfaceAttributeRequest(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*request.Request, *ec2.ModifyNetworkInterfaceAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyNetworkInterfaceAttributeOutput) + return ret0, ret1 +} + +// ModifyNetworkInterfaceAttributeRequest indicates an expected call of ModifyNetworkInterfaceAttributeRequest +func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeRequest), arg0) +} + +// ModifyNetworkInterfaceAttributeWithContext mocks base method +func (m *MockEC2API) ModifyNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyNetworkInterfaceAttributeWithContext indicates an expected call of ModifyNetworkInterfaceAttributeWithContext +func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeWithContext), varargs...) +} + +// ModifyReservedInstances mocks base method +func (m *MockEC2API) ModifyReservedInstances(arg0 *ec2.ModifyReservedInstancesInput) (*ec2.ModifyReservedInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyReservedInstances", arg0) + ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyReservedInstances indicates an expected call of ModifyReservedInstances +func (mr *MockEC2APIMockRecorder) ModifyReservedInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstances", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstances), arg0) +} + +// ModifyReservedInstancesRequest mocks base method +func (m *MockEC2API) ModifyReservedInstancesRequest(arg0 *ec2.ModifyReservedInstancesInput) (*request.Request, *ec2.ModifyReservedInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyReservedInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyReservedInstancesOutput) + return ret0, ret1 +} + +// ModifyReservedInstancesRequest indicates an expected call of ModifyReservedInstancesRequest +func (mr *MockEC2APIMockRecorder) ModifyReservedInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstancesRequest), arg0) +} + +// ModifyReservedInstancesWithContext mocks base method +func (m *MockEC2API) ModifyReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.ModifyReservedInstancesInput, arg2 ...request.Option) (*ec2.ModifyReservedInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyReservedInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyReservedInstancesWithContext indicates an expected call of ModifyReservedInstancesWithContext +func (mr *MockEC2APIMockRecorder) ModifyReservedInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstancesWithContext), varargs...) +} + +// ModifySnapshotAttribute mocks base method +func (m *MockEC2API) ModifySnapshotAttribute(arg0 *ec2.ModifySnapshotAttributeInput) (*ec2.ModifySnapshotAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifySnapshotAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifySnapshotAttribute indicates an expected call of ModifySnapshotAttribute +func (mr *MockEC2APIMockRecorder) ModifySnapshotAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttribute), arg0) +} + +// ModifySnapshotAttributeRequest mocks base method +func (m *MockEC2API) ModifySnapshotAttributeRequest(arg0 *ec2.ModifySnapshotAttributeInput) (*request.Request, *ec2.ModifySnapshotAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifySnapshotAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifySnapshotAttributeOutput) + return ret0, ret1 +} + +// ModifySnapshotAttributeRequest indicates an expected call of ModifySnapshotAttributeRequest +func (mr *MockEC2APIMockRecorder) ModifySnapshotAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttributeRequest), arg0) +} + +// ModifySnapshotAttributeWithContext mocks base method +func (m *MockEC2API) ModifySnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifySnapshotAttributeInput, arg2 ...request.Option) (*ec2.ModifySnapshotAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifySnapshotAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifySnapshotAttributeWithContext indicates an expected call of ModifySnapshotAttributeWithContext +func (mr *MockEC2APIMockRecorder) ModifySnapshotAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttributeWithContext), varargs...) +} + +// ModifySpotFleetRequest mocks base method +func (m *MockEC2API) ModifySpotFleetRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*ec2.ModifySpotFleetRequestOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifySpotFleetRequest", arg0) + ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifySpotFleetRequest indicates an expected call of ModifySpotFleetRequest +func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequest), arg0) +} + +// ModifySpotFleetRequestRequest mocks base method +func (m *MockEC2API) ModifySpotFleetRequestRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*request.Request, *ec2.ModifySpotFleetRequestOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifySpotFleetRequestRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifySpotFleetRequestOutput) + return ret0, ret1 +} + +// ModifySpotFleetRequestRequest indicates an expected call of ModifySpotFleetRequestRequest +func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequestRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequestRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequestRequest), arg0) +} + +// ModifySpotFleetRequestWithContext mocks base method +func (m *MockEC2API) ModifySpotFleetRequestWithContext(arg0 context.Context, arg1 *ec2.ModifySpotFleetRequestInput, arg2 ...request.Option) (*ec2.ModifySpotFleetRequestOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifySpotFleetRequestWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifySpotFleetRequestWithContext indicates an expected call of ModifySpotFleetRequestWithContext +func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequestWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequestWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequestWithContext), varargs...) +} + +// ModifySubnetAttribute mocks base method +func (m *MockEC2API) ModifySubnetAttribute(arg0 *ec2.ModifySubnetAttributeInput) (*ec2.ModifySubnetAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifySubnetAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifySubnetAttribute indicates an expected call of ModifySubnetAttribute +func (mr *MockEC2APIMockRecorder) ModifySubnetAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttribute), arg0) +} + +// ModifySubnetAttributeRequest mocks base method +func (m *MockEC2API) ModifySubnetAttributeRequest(arg0 *ec2.ModifySubnetAttributeInput) (*request.Request, *ec2.ModifySubnetAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifySubnetAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifySubnetAttributeOutput) + return ret0, ret1 +} + +// ModifySubnetAttributeRequest indicates an expected call of ModifySubnetAttributeRequest +func (mr *MockEC2APIMockRecorder) ModifySubnetAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttributeRequest), arg0) +} + +// ModifySubnetAttributeWithContext mocks base method +func (m *MockEC2API) ModifySubnetAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifySubnetAttributeInput, arg2 ...request.Option) (*ec2.ModifySubnetAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifySubnetAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifySubnetAttributeWithContext indicates an expected call of ModifySubnetAttributeWithContext +func (mr *MockEC2APIMockRecorder) ModifySubnetAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttributeWithContext), varargs...) +} + +// ModifyTrafficMirrorFilterNetworkServices mocks base method +func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServices(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServices", arg0) + ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTrafficMirrorFilterNetworkServices indicates an expected call of ModifyTrafficMirrorFilterNetworkServices +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServices(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServices", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServices), arg0) +} + +// ModifyTrafficMirrorFilterNetworkServicesRequest mocks base method +func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) + return ret0, ret1 +} + +// ModifyTrafficMirrorFilterNetworkServicesRequest indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesRequest +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServicesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesRequest), arg0) +} + +// ModifyTrafficMirrorFilterNetworkServicesWithContext mocks base method +func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTrafficMirrorFilterNetworkServicesWithContext indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesWithContext +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServicesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesWithContext), varargs...) +} + +// ModifyTrafficMirrorFilterRule mocks base method +func (m *MockEC2API) ModifyTrafficMirrorFilterRule(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRule", arg0) + ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTrafficMirrorFilterRule indicates an expected call of ModifyTrafficMirrorFilterRule +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRule), arg0) +} + +// ModifyTrafficMirrorFilterRuleRequest mocks base method +func (m *MockEC2API) ModifyTrafficMirrorFilterRuleRequest(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterRuleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterRuleOutput) + return ret0, ret1 +} + +// ModifyTrafficMirrorFilterRuleRequest indicates an expected call of ModifyTrafficMirrorFilterRuleRequest +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleRequest), arg0) +} + +// ModifyTrafficMirrorFilterRuleWithContext mocks base method +func (m *MockEC2API) ModifyTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTrafficMirrorFilterRuleWithContext indicates an expected call of ModifyTrafficMirrorFilterRuleWithContext +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleWithContext), varargs...) +} + +// ModifyTrafficMirrorSession mocks base method +func (m *MockEC2API) ModifyTrafficMirrorSession(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*ec2.ModifyTrafficMirrorSessionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTrafficMirrorSession", arg0) + ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTrafficMirrorSession indicates an expected call of ModifyTrafficMirrorSession +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSession(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSession), arg0) +} + +// ModifyTrafficMirrorSessionRequest mocks base method +func (m *MockEC2API) ModifyTrafficMirrorSessionRequest(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*request.Request, *ec2.ModifyTrafficMirrorSessionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorSessionOutput) + return ret0, ret1 +} + +// ModifyTrafficMirrorSessionRequest indicates an expected call of ModifyTrafficMirrorSessionRequest +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSessionRequest), arg0) +} + +// ModifyTrafficMirrorSessionWithContext mocks base method +func (m *MockEC2API) ModifyTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorSessionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTrafficMirrorSessionWithContext indicates an expected call of ModifyTrafficMirrorSessionWithContext +func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSessionWithContext), varargs...) +} + +// ModifyTransitGateway mocks base method +func (m *MockEC2API) ModifyTransitGateway(arg0 *ec2.ModifyTransitGatewayInput) (*ec2.ModifyTransitGatewayOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTransitGateway", arg0) + ret0, _ := ret[0].(*ec2.ModifyTransitGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTransitGateway indicates an expected call of ModifyTransitGateway +func (mr *MockEC2APIMockRecorder) ModifyTransitGateway(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGateway", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGateway), arg0) +} + +// ModifyTransitGatewayPrefixListReference mocks base method +func (m *MockEC2API) ModifyTransitGatewayPrefixListReference(arg0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReference", arg0) + ret0, _ := ret[0].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTransitGatewayPrefixListReference indicates an expected call of ModifyTransitGatewayPrefixListReference +func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayPrefixListReference), arg0) +} + +// ModifyTransitGatewayPrefixListReferenceRequest mocks base method +func (m *MockEC2API) ModifyTransitGatewayPrefixListReferenceRequest(arg0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.ModifyTransitGatewayPrefixListReferenceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReferenceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput) + return ret0, ret1 +} + +// ModifyTransitGatewayPrefixListReferenceRequest indicates an expected call of ModifyTransitGatewayPrefixListReferenceRequest +func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayPrefixListReferenceRequest), arg0) +} + +// ModifyTransitGatewayPrefixListReferenceWithContext mocks base method +func (m *MockEC2API) ModifyTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReferenceWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTransitGatewayPrefixListReferenceWithContext indicates an expected call of ModifyTransitGatewayPrefixListReferenceWithContext +func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayPrefixListReferenceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayPrefixListReferenceWithContext), varargs...) +} + +// ModifyTransitGatewayRequest mocks base method +func (m *MockEC2API) ModifyTransitGatewayRequest(arg0 *ec2.ModifyTransitGatewayInput) (*request.Request, *ec2.ModifyTransitGatewayOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTransitGatewayRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyTransitGatewayOutput) + return ret0, ret1 +} + +// ModifyTransitGatewayRequest indicates an expected call of ModifyTransitGatewayRequest +func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayRequest), arg0) +} + +// ModifyTransitGatewayVpcAttachment mocks base method +func (m *MockEC2API) ModifyTransitGatewayVpcAttachment(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachment", arg0) + ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTransitGatewayVpcAttachment indicates an expected call of ModifyTransitGatewayVpcAttachment +func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachment), arg0) +} + +// ModifyTransitGatewayVpcAttachmentRequest mocks base method +func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentRequest(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.ModifyTransitGatewayVpcAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) + return ret0, ret1 +} + +// ModifyTransitGatewayVpcAttachmentRequest indicates an expected call of ModifyTransitGatewayVpcAttachmentRequest +func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentRequest), arg0) +} + +// ModifyTransitGatewayVpcAttachmentWithContext mocks base method +func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTransitGatewayVpcAttachmentWithContext indicates an expected call of ModifyTransitGatewayVpcAttachmentWithContext +func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentWithContext), varargs...) +} + +// ModifyTransitGatewayWithContext mocks base method +func (m *MockEC2API) ModifyTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyTransitGatewayWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyTransitGatewayOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyTransitGatewayWithContext indicates an expected call of ModifyTransitGatewayWithContext +func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayWithContext), varargs...) +} + +// ModifyVolume mocks base method +func (m *MockEC2API) ModifyVolume(arg0 *ec2.ModifyVolumeInput) (*ec2.ModifyVolumeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVolume", arg0) + ret0, _ := ret[0].(*ec2.ModifyVolumeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVolume indicates an expected call of ModifyVolume +func (mr *MockEC2APIMockRecorder) ModifyVolume(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolume", reflect.TypeOf((*MockEC2API)(nil).ModifyVolume), arg0) +} + +// ModifyVolumeAttribute mocks base method +func (m *MockEC2API) ModifyVolumeAttribute(arg0 *ec2.ModifyVolumeAttributeInput) (*ec2.ModifyVolumeAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVolumeAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVolumeAttribute indicates an expected call of ModifyVolumeAttribute +func (mr *MockEC2APIMockRecorder) ModifyVolumeAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttribute), arg0) +} + +// ModifyVolumeAttributeRequest mocks base method +func (m *MockEC2API) ModifyVolumeAttributeRequest(arg0 *ec2.ModifyVolumeAttributeInput) (*request.Request, *ec2.ModifyVolumeAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVolumeAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVolumeAttributeOutput) + return ret0, ret1 +} + +// ModifyVolumeAttributeRequest indicates an expected call of ModifyVolumeAttributeRequest +func (mr *MockEC2APIMockRecorder) ModifyVolumeAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttributeRequest), arg0) +} + +// ModifyVolumeAttributeWithContext mocks base method +func (m *MockEC2API) ModifyVolumeAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeAttributeInput, arg2 ...request.Option) (*ec2.ModifyVolumeAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVolumeAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVolumeAttributeWithContext indicates an expected call of ModifyVolumeAttributeWithContext +func (mr *MockEC2APIMockRecorder) ModifyVolumeAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttributeWithContext), varargs...) +} + +// ModifyVolumeRequest mocks base method +func (m *MockEC2API) ModifyVolumeRequest(arg0 *ec2.ModifyVolumeInput) (*request.Request, *ec2.ModifyVolumeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVolumeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVolumeOutput) + return ret0, ret1 +} + +// ModifyVolumeRequest indicates an expected call of ModifyVolumeRequest +func (mr *MockEC2APIMockRecorder) ModifyVolumeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeRequest), arg0) +} + +// ModifyVolumeWithContext mocks base method +func (m *MockEC2API) ModifyVolumeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeInput, arg2 ...request.Option) (*ec2.ModifyVolumeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVolumeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVolumeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVolumeWithContext indicates an expected call of ModifyVolumeWithContext +func (mr *MockEC2APIMockRecorder) ModifyVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeWithContext), varargs...) +} + +// ModifyVpcAttribute mocks base method +func (m *MockEC2API) ModifyVpcAttribute(arg0 *ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcAttribute", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcAttribute indicates an expected call of ModifyVpcAttribute +func (mr *MockEC2APIMockRecorder) ModifyVpcAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttribute), arg0) +} + +// ModifyVpcAttributeRequest mocks base method +func (m *MockEC2API) ModifyVpcAttributeRequest(arg0 *ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpcAttributeOutput) + return ret0, ret1 +} + +// ModifyVpcAttributeRequest indicates an expected call of ModifyVpcAttributeRequest +func (mr *MockEC2APIMockRecorder) ModifyVpcAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttributeRequest), arg0) +} + +// ModifyVpcAttributeWithContext mocks base method +func (m *MockEC2API) ModifyVpcAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcAttributeInput, arg2 ...request.Option) (*ec2.ModifyVpcAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpcAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcAttributeWithContext indicates an expected call of ModifyVpcAttributeWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpcAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttributeWithContext), varargs...) +} + +// ModifyVpcEndpoint mocks base method +func (m *MockEC2API) ModifyVpcEndpoint(arg0 *ec2.ModifyVpcEndpointInput) (*ec2.ModifyVpcEndpointOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcEndpoint", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcEndpoint indicates an expected call of ModifyVpcEndpoint +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpoint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpoint), arg0) +} + +// ModifyVpcEndpointConnectionNotification mocks base method +func (m *MockEC2API) ModifyVpcEndpointConnectionNotification(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotification", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcEndpointConnectionNotification indicates an expected call of ModifyVpcEndpointConnectionNotification +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotification), arg0) +} + +// ModifyVpcEndpointConnectionNotificationRequest mocks base method +func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationRequest(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.ModifyVpcEndpointConnectionNotificationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) + return ret0, ret1 +} + +// ModifyVpcEndpointConnectionNotificationRequest indicates an expected call of ModifyVpcEndpointConnectionNotificationRequest +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationRequest), arg0) +} + +// ModifyVpcEndpointConnectionNotificationWithContext mocks base method +func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcEndpointConnectionNotificationWithContext indicates an expected call of ModifyVpcEndpointConnectionNotificationWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotificationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationWithContext), varargs...) +} + +// ModifyVpcEndpointRequest mocks base method +func (m *MockEC2API) ModifyVpcEndpointRequest(arg0 *ec2.ModifyVpcEndpointInput) (*request.Request, *ec2.ModifyVpcEndpointOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcEndpointRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpcEndpointOutput) + return ret0, ret1 +} + +// ModifyVpcEndpointRequest indicates an expected call of ModifyVpcEndpointRequest +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointRequest), arg0) +} + +// ModifyVpcEndpointServiceConfiguration mocks base method +func (m *MockEC2API) ModifyVpcEndpointServiceConfiguration(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfiguration", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcEndpointServiceConfiguration indicates an expected call of ModifyVpcEndpointServiceConfiguration +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfiguration), arg0) +} + +// ModifyVpcEndpointServiceConfigurationRequest mocks base method +func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationRequest(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.ModifyVpcEndpointServiceConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) + return ret0, ret1 +} + +// ModifyVpcEndpointServiceConfigurationRequest indicates an expected call of ModifyVpcEndpointServiceConfigurationRequest +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationRequest), arg0) +} + +// ModifyVpcEndpointServiceConfigurationWithContext mocks base method +func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcEndpointServiceConfigurationWithContext indicates an expected call of ModifyVpcEndpointServiceConfigurationWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationWithContext), varargs...) +} + +// ModifyVpcEndpointServicePermissions mocks base method +func (m *MockEC2API) ModifyVpcEndpointServicePermissions(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissions", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcEndpointServicePermissions indicates an expected call of ModifyVpcEndpointServicePermissions +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissions), arg0) +} + +// ModifyVpcEndpointServicePermissionsRequest mocks base method +func (m *MockEC2API) ModifyVpcEndpointServicePermissionsRequest(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*request.Request, *ec2.ModifyVpcEndpointServicePermissionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServicePermissionsOutput) + return ret0, ret1 +} + +// ModifyVpcEndpointServicePermissionsRequest indicates an expected call of ModifyVpcEndpointServicePermissionsRequest +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsRequest), arg0) +} + +// ModifyVpcEndpointServicePermissionsWithContext mocks base method +func (m *MockEC2API) ModifyVpcEndpointServicePermissionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcEndpointServicePermissionsWithContext indicates an expected call of ModifyVpcEndpointServicePermissionsWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsWithContext), varargs...) +} + +// ModifyVpcEndpointWithContext mocks base method +func (m *MockEC2API) ModifyVpcEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpcEndpointWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcEndpointWithContext indicates an expected call of ModifyVpcEndpointWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointWithContext), varargs...) +} + +// ModifyVpcPeeringConnectionOptions mocks base method +func (m *MockEC2API) ModifyVpcPeeringConnectionOptions(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptions", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcPeeringConnectionOptions indicates an expected call of ModifyVpcPeeringConnectionOptions +func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptions), arg0) +} + +// ModifyVpcPeeringConnectionOptionsRequest mocks base method +func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsRequest(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*request.Request, *ec2.ModifyVpcPeeringConnectionOptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) + return ret0, ret1 +} + +// ModifyVpcPeeringConnectionOptionsRequest indicates an expected call of ModifyVpcPeeringConnectionOptionsRequest +func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsRequest), arg0) +} + +// ModifyVpcPeeringConnectionOptionsWithContext mocks base method +func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcPeeringConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcPeeringConnectionOptionsWithContext indicates an expected call of ModifyVpcPeeringConnectionOptionsWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsWithContext), varargs...) +} + +// ModifyVpcTenancy mocks base method +func (m *MockEC2API) ModifyVpcTenancy(arg0 *ec2.ModifyVpcTenancyInput) (*ec2.ModifyVpcTenancyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcTenancy", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcTenancy indicates an expected call of ModifyVpcTenancy +func (mr *MockEC2APIMockRecorder) ModifyVpcTenancy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancy", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancy), arg0) +} + +// ModifyVpcTenancyRequest mocks base method +func (m *MockEC2API) ModifyVpcTenancyRequest(arg0 *ec2.ModifyVpcTenancyInput) (*request.Request, *ec2.ModifyVpcTenancyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpcTenancyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpcTenancyOutput) + return ret0, ret1 +} + +// ModifyVpcTenancyRequest indicates an expected call of ModifyVpcTenancyRequest +func (mr *MockEC2APIMockRecorder) ModifyVpcTenancyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancyRequest), arg0) +} + +// ModifyVpcTenancyWithContext mocks base method +func (m *MockEC2API) ModifyVpcTenancyWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcTenancyInput, arg2 ...request.Option) (*ec2.ModifyVpcTenancyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpcTenancyWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpcTenancyWithContext indicates an expected call of ModifyVpcTenancyWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpcTenancyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancyWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancyWithContext), varargs...) +} + +// ModifyVpnConnection mocks base method +func (m *MockEC2API) ModifyVpnConnection(arg0 *ec2.ModifyVpnConnectionInput) (*ec2.ModifyVpnConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpnConnection", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpnConnection indicates an expected call of ModifyVpnConnection +func (mr *MockEC2APIMockRecorder) ModifyVpnConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnection", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnection), arg0) +} + +// ModifyVpnConnectionOptions mocks base method +func (m *MockEC2API) ModifyVpnConnectionOptions(arg0 *ec2.ModifyVpnConnectionOptionsInput) (*ec2.ModifyVpnConnectionOptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpnConnectionOptions", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpnConnectionOptions indicates an expected call of ModifyVpnConnectionOptions +func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionOptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionOptions), arg0) +} + +// ModifyVpnConnectionOptionsRequest mocks base method +func (m *MockEC2API) ModifyVpnConnectionOptionsRequest(arg0 *ec2.ModifyVpnConnectionOptionsInput) (*request.Request, *ec2.ModifyVpnConnectionOptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpnConnectionOptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOptionsOutput) + return ret0, ret1 +} + +// ModifyVpnConnectionOptionsRequest indicates an expected call of ModifyVpnConnectionOptionsRequest +func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionOptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionOptionsRequest), arg0) +} + +// ModifyVpnConnectionOptionsWithContext mocks base method +func (m *MockEC2API) ModifyVpnConnectionOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpnConnectionOptionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpnConnectionOptionsWithContext indicates an expected call of ModifyVpnConnectionOptionsWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionOptionsWithContext), varargs...) +} + +// ModifyVpnConnectionRequest mocks base method +func (m *MockEC2API) ModifyVpnConnectionRequest(arg0 *ec2.ModifyVpnConnectionInput) (*request.Request, *ec2.ModifyVpnConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpnConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOutput) + return ret0, ret1 +} + +// ModifyVpnConnectionRequest indicates an expected call of ModifyVpnConnectionRequest +func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionRequest), arg0) +} + +// ModifyVpnConnectionWithContext mocks base method +func (m *MockEC2API) ModifyVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnConnectionInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpnConnectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpnConnectionWithContext indicates an expected call of ModifyVpnConnectionWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionWithContext), varargs...) +} + +// ModifyVpnTunnelCertificate mocks base method +func (m *MockEC2API) ModifyVpnTunnelCertificate(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*ec2.ModifyVpnTunnelCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificate", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpnTunnelCertificate indicates an expected call of ModifyVpnTunnelCertificate +func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificate", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificate), arg0) +} + +// ModifyVpnTunnelCertificateRequest mocks base method +func (m *MockEC2API) ModifyVpnTunnelCertificateRequest(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*request.Request, *ec2.ModifyVpnTunnelCertificateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpnTunnelCertificateOutput) + return ret0, ret1 +} + +// ModifyVpnTunnelCertificateRequest indicates an expected call of ModifyVpnTunnelCertificateRequest +func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificateRequest), arg0) +} + +// ModifyVpnTunnelCertificateWithContext mocks base method +func (m *MockEC2API) ModifyVpnTunnelCertificateWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnTunnelCertificateInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelCertificateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpnTunnelCertificateWithContext indicates an expected call of ModifyVpnTunnelCertificateWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificateWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificateWithContext), varargs...) +} + +// ModifyVpnTunnelOptions mocks base method +func (m *MockEC2API) ModifyVpnTunnelOptions(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*ec2.ModifyVpnTunnelOptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpnTunnelOptions", arg0) + ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpnTunnelOptions indicates an expected call of ModifyVpnTunnelOptions +func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptions), arg0) +} + +// ModifyVpnTunnelOptionsRequest mocks base method +func (m *MockEC2API) ModifyVpnTunnelOptionsRequest(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*request.Request, *ec2.ModifyVpnTunnelOptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ModifyVpnTunnelOptionsOutput) + return ret0, ret1 +} + +// ModifyVpnTunnelOptionsRequest indicates an expected call of ModifyVpnTunnelOptionsRequest +func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptionsRequest), arg0) +} + +// ModifyVpnTunnelOptionsWithContext mocks base method +func (m *MockEC2API) ModifyVpnTunnelOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnTunnelOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelOptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ModifyVpnTunnelOptionsWithContext indicates an expected call of ModifyVpnTunnelOptionsWithContext +func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptionsWithContext), varargs...) +} + +// MonitorInstances mocks base method +func (m *MockEC2API) MonitorInstances(arg0 *ec2.MonitorInstancesInput) (*ec2.MonitorInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MonitorInstances", arg0) + ret0, _ := ret[0].(*ec2.MonitorInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MonitorInstances indicates an expected call of MonitorInstances +func (mr *MockEC2APIMockRecorder) MonitorInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstances", reflect.TypeOf((*MockEC2API)(nil).MonitorInstances), arg0) +} + +// MonitorInstancesRequest mocks base method +func (m *MockEC2API) MonitorInstancesRequest(arg0 *ec2.MonitorInstancesInput) (*request.Request, *ec2.MonitorInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MonitorInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.MonitorInstancesOutput) + return ret0, ret1 +} + +// MonitorInstancesRequest indicates an expected call of MonitorInstancesRequest +func (mr *MockEC2APIMockRecorder) MonitorInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).MonitorInstancesRequest), arg0) +} + +// MonitorInstancesWithContext mocks base method +func (m *MockEC2API) MonitorInstancesWithContext(arg0 context.Context, arg1 *ec2.MonitorInstancesInput, arg2 ...request.Option) (*ec2.MonitorInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MonitorInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.MonitorInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MonitorInstancesWithContext indicates an expected call of MonitorInstancesWithContext +func (mr *MockEC2APIMockRecorder) MonitorInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).MonitorInstancesWithContext), varargs...) +} + +// MoveAddressToVpc mocks base method +func (m *MockEC2API) MoveAddressToVpc(arg0 *ec2.MoveAddressToVpcInput) (*ec2.MoveAddressToVpcOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MoveAddressToVpc", arg0) + ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MoveAddressToVpc indicates an expected call of MoveAddressToVpc +func (mr *MockEC2APIMockRecorder) MoveAddressToVpc(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpc", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpc), arg0) +} + +// MoveAddressToVpcRequest mocks base method +func (m *MockEC2API) MoveAddressToVpcRequest(arg0 *ec2.MoveAddressToVpcInput) (*request.Request, *ec2.MoveAddressToVpcOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MoveAddressToVpcRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.MoveAddressToVpcOutput) + return ret0, ret1 +} + +// MoveAddressToVpcRequest indicates an expected call of MoveAddressToVpcRequest +func (mr *MockEC2APIMockRecorder) MoveAddressToVpcRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpcRequest", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpcRequest), arg0) +} + +// MoveAddressToVpcWithContext mocks base method +func (m *MockEC2API) MoveAddressToVpcWithContext(arg0 context.Context, arg1 *ec2.MoveAddressToVpcInput, arg2 ...request.Option) (*ec2.MoveAddressToVpcOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MoveAddressToVpcWithContext", varargs...) + ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MoveAddressToVpcWithContext indicates an expected call of MoveAddressToVpcWithContext +func (mr *MockEC2APIMockRecorder) MoveAddressToVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpcWithContext), varargs...) +} + +// ProvisionByoipCidr mocks base method +func (m *MockEC2API) ProvisionByoipCidr(arg0 *ec2.ProvisionByoipCidrInput) (*ec2.ProvisionByoipCidrOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProvisionByoipCidr", arg0) + ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProvisionByoipCidr indicates an expected call of ProvisionByoipCidr +func (mr *MockEC2APIMockRecorder) ProvisionByoipCidr(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidr), arg0) +} + +// ProvisionByoipCidrRequest mocks base method +func (m *MockEC2API) ProvisionByoipCidrRequest(arg0 *ec2.ProvisionByoipCidrInput) (*request.Request, *ec2.ProvisionByoipCidrOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProvisionByoipCidrRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ProvisionByoipCidrOutput) + return ret0, ret1 +} + +// ProvisionByoipCidrRequest indicates an expected call of ProvisionByoipCidrRequest +func (mr *MockEC2APIMockRecorder) ProvisionByoipCidrRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidrRequest), arg0) +} + +// ProvisionByoipCidrWithContext mocks base method +func (m *MockEC2API) ProvisionByoipCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionByoipCidrInput, arg2 ...request.Option) (*ec2.ProvisionByoipCidrOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ProvisionByoipCidrWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProvisionByoipCidrWithContext indicates an expected call of ProvisionByoipCidrWithContext +func (mr *MockEC2APIMockRecorder) ProvisionByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidrWithContext), varargs...) +} + +// PurchaseHostReservation mocks base method +func (m *MockEC2API) PurchaseHostReservation(arg0 *ec2.PurchaseHostReservationInput) (*ec2.PurchaseHostReservationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurchaseHostReservation", arg0) + ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurchaseHostReservation indicates an expected call of PurchaseHostReservation +func (mr *MockEC2APIMockRecorder) PurchaseHostReservation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservation", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservation), arg0) +} + +// PurchaseHostReservationRequest mocks base method +func (m *MockEC2API) PurchaseHostReservationRequest(arg0 *ec2.PurchaseHostReservationInput) (*request.Request, *ec2.PurchaseHostReservationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurchaseHostReservationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.PurchaseHostReservationOutput) + return ret0, ret1 +} + +// PurchaseHostReservationRequest indicates an expected call of PurchaseHostReservationRequest +func (mr *MockEC2APIMockRecorder) PurchaseHostReservationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservationRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservationRequest), arg0) +} + +// PurchaseHostReservationWithContext mocks base method +func (m *MockEC2API) PurchaseHostReservationWithContext(arg0 context.Context, arg1 *ec2.PurchaseHostReservationInput, arg2 ...request.Option) (*ec2.PurchaseHostReservationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PurchaseHostReservationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurchaseHostReservationWithContext indicates an expected call of PurchaseHostReservationWithContext +func (mr *MockEC2APIMockRecorder) PurchaseHostReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservationWithContext), varargs...) +} + +// PurchaseReservedInstancesOffering mocks base method +func (m *MockEC2API) PurchaseReservedInstancesOffering(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*ec2.PurchaseReservedInstancesOfferingOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurchaseReservedInstancesOffering", arg0) + ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurchaseReservedInstancesOffering indicates an expected call of PurchaseReservedInstancesOffering +func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOffering(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOffering", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOffering), arg0) +} + +// PurchaseReservedInstancesOfferingRequest mocks base method +func (m *MockEC2API) PurchaseReservedInstancesOfferingRequest(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*request.Request, *ec2.PurchaseReservedInstancesOfferingOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.PurchaseReservedInstancesOfferingOutput) + return ret0, ret1 +} + +// PurchaseReservedInstancesOfferingRequest indicates an expected call of PurchaseReservedInstancesOfferingRequest +func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOfferingRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOfferingRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOfferingRequest), arg0) +} + +// PurchaseReservedInstancesOfferingWithContext mocks base method +func (m *MockEC2API) PurchaseReservedInstancesOfferingWithContext(arg0 context.Context, arg1 *ec2.PurchaseReservedInstancesOfferingInput, arg2 ...request.Option) (*ec2.PurchaseReservedInstancesOfferingOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingWithContext", varargs...) + ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurchaseReservedInstancesOfferingWithContext indicates an expected call of PurchaseReservedInstancesOfferingWithContext +func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOfferingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOfferingWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOfferingWithContext), varargs...) +} + +// PurchaseScheduledInstances mocks base method +func (m *MockEC2API) PurchaseScheduledInstances(arg0 *ec2.PurchaseScheduledInstancesInput) (*ec2.PurchaseScheduledInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurchaseScheduledInstances", arg0) + ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurchaseScheduledInstances indicates an expected call of PurchaseScheduledInstances +func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstances), arg0) +} + +// PurchaseScheduledInstancesRequest mocks base method +func (m *MockEC2API) PurchaseScheduledInstancesRequest(arg0 *ec2.PurchaseScheduledInstancesInput) (*request.Request, *ec2.PurchaseScheduledInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PurchaseScheduledInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.PurchaseScheduledInstancesOutput) + return ret0, ret1 +} + +// PurchaseScheduledInstancesRequest indicates an expected call of PurchaseScheduledInstancesRequest +func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstancesRequest), arg0) +} + +// PurchaseScheduledInstancesWithContext mocks base method +func (m *MockEC2API) PurchaseScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.PurchaseScheduledInstancesInput, arg2 ...request.Option) (*ec2.PurchaseScheduledInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PurchaseScheduledInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PurchaseScheduledInstancesWithContext indicates an expected call of PurchaseScheduledInstancesWithContext +func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstancesWithContext), varargs...) +} + +// RebootInstances mocks base method +func (m *MockEC2API) RebootInstances(arg0 *ec2.RebootInstancesInput) (*ec2.RebootInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RebootInstances", arg0) + ret0, _ := ret[0].(*ec2.RebootInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RebootInstances indicates an expected call of RebootInstances +func (mr *MockEC2APIMockRecorder) RebootInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstances", reflect.TypeOf((*MockEC2API)(nil).RebootInstances), arg0) +} + +// RebootInstancesRequest mocks base method +func (m *MockEC2API) RebootInstancesRequest(arg0 *ec2.RebootInstancesInput) (*request.Request, *ec2.RebootInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RebootInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RebootInstancesOutput) + return ret0, ret1 +} + +// RebootInstancesRequest indicates an expected call of RebootInstancesRequest +func (mr *MockEC2APIMockRecorder) RebootInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RebootInstancesRequest), arg0) +} + +// RebootInstancesWithContext mocks base method +func (m *MockEC2API) RebootInstancesWithContext(arg0 context.Context, arg1 *ec2.RebootInstancesInput, arg2 ...request.Option) (*ec2.RebootInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RebootInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RebootInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RebootInstancesWithContext indicates an expected call of RebootInstancesWithContext +func (mr *MockEC2APIMockRecorder) RebootInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RebootInstancesWithContext), varargs...) +} + +// RegisterImage mocks base method +func (m *MockEC2API) RegisterImage(arg0 *ec2.RegisterImageInput) (*ec2.RegisterImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterImage", arg0) + ret0, _ := ret[0].(*ec2.RegisterImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterImage indicates an expected call of RegisterImage +func (mr *MockEC2APIMockRecorder) RegisterImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImage", reflect.TypeOf((*MockEC2API)(nil).RegisterImage), arg0) +} + +// RegisterImageRequest mocks base method +func (m *MockEC2API) RegisterImageRequest(arg0 *ec2.RegisterImageInput) (*request.Request, *ec2.RegisterImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RegisterImageOutput) + return ret0, ret1 +} + +// RegisterImageRequest indicates an expected call of RegisterImageRequest +func (mr *MockEC2APIMockRecorder) RegisterImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterImageRequest), arg0) +} + +// RegisterImageWithContext mocks base method +func (m *MockEC2API) RegisterImageWithContext(arg0 context.Context, arg1 *ec2.RegisterImageInput, arg2 ...request.Option) (*ec2.RegisterImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterImageWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RegisterImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterImageWithContext indicates an expected call of RegisterImageWithContext +func (mr *MockEC2APIMockRecorder) RegisterImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImageWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterImageWithContext), varargs...) +} + +// RegisterInstanceEventNotificationAttributes mocks base method +func (m *MockEC2API) RegisterInstanceEventNotificationAttributes(arg0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributes", arg0) + ret0, _ := ret[0].(*ec2.RegisterInstanceEventNotificationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterInstanceEventNotificationAttributes indicates an expected call of RegisterInstanceEventNotificationAttributes +func (mr *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributes), arg0) +} + +// RegisterInstanceEventNotificationAttributesRequest mocks base method +func (m *MockEC2API) RegisterInstanceEventNotificationAttributesRequest(arg0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.RegisterInstanceEventNotificationAttributesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RegisterInstanceEventNotificationAttributesOutput) + return ret0, ret1 +} + +// RegisterInstanceEventNotificationAttributesRequest indicates an expected call of RegisterInstanceEventNotificationAttributesRequest +func (mr *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributesRequest), arg0) +} + +// RegisterInstanceEventNotificationAttributesWithContext mocks base method +func (m *MockEC2API) RegisterInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.RegisterInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RegisterInstanceEventNotificationAttributesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterInstanceEventNotificationAttributesWithContext indicates an expected call of RegisterInstanceEventNotificationAttributesWithContext +func (mr *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributesWithContext), varargs...) +} + +// RegisterTransitGatewayMulticastGroupMembers mocks base method +func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembers(arg0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembers", arg0) + ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterTransitGatewayMulticastGroupMembers indicates an expected call of RegisterTransitGatewayMulticastGroupMembers +func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembers), arg0) +} + +// RegisterTransitGatewayMulticastGroupMembersRequest mocks base method +func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupMembersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput) + return ret0, ret1 +} + +// RegisterTransitGatewayMulticastGroupMembersRequest indicates an expected call of RegisterTransitGatewayMulticastGroupMembersRequest +func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembersRequest), arg0) +} + +// RegisterTransitGatewayMulticastGroupMembersWithContext mocks base method +func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembersWithContext(arg0 context.Context, arg1 *ec2.RegisterTransitGatewayMulticastGroupMembersInput, arg2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembersWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterTransitGatewayMulticastGroupMembersWithContext indicates an expected call of RegisterTransitGatewayMulticastGroupMembersWithContext +func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembersWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembersWithContext), varargs...) +} + +// RegisterTransitGatewayMulticastGroupSources mocks base method +func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSources(arg0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSources", arg0) + ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterTransitGatewayMulticastGroupSources indicates an expected call of RegisterTransitGatewayMulticastGroupSources +func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSources), arg0) +} + +// RegisterTransitGatewayMulticastGroupSourcesRequest mocks base method +func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSourcesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) + return ret0, ret1 +} + +// RegisterTransitGatewayMulticastGroupSourcesRequest indicates an expected call of RegisterTransitGatewayMulticastGroupSourcesRequest +func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSourcesRequest), arg0) +} + +// RegisterTransitGatewayMulticastGroupSourcesWithContext mocks base method +func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSourcesWithContext(arg0 context.Context, arg1 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, arg2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSourcesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterTransitGatewayMulticastGroupSourcesWithContext indicates an expected call of RegisterTransitGatewayMulticastGroupSourcesWithContext +func (mr *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSourcesWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSourcesWithContext), varargs...) +} + +// RejectTransitGatewayPeeringAttachment mocks base method +func (m *MockEC2API) RejectTransitGatewayPeeringAttachment(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachment", arg0) + ret0, _ := ret[0].(*ec2.RejectTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectTransitGatewayPeeringAttachment indicates an expected call of RejectTransitGatewayPeeringAttachment +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachment), arg0) +} + +// RejectTransitGatewayPeeringAttachmentRequest mocks base method +func (m *MockEC2API) RejectTransitGatewayPeeringAttachmentRequest(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayPeeringAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RejectTransitGatewayPeeringAttachmentOutput) + return ret0, ret1 +} + +// RejectTransitGatewayPeeringAttachmentRequest indicates an expected call of RejectTransitGatewayPeeringAttachmentRequest +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachmentRequest), arg0) +} + +// RejectTransitGatewayPeeringAttachmentWithContext mocks base method +func (m *MockEC2API) RejectTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RejectTransitGatewayPeeringAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectTransitGatewayPeeringAttachmentWithContext indicates an expected call of RejectTransitGatewayPeeringAttachmentWithContext +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachmentWithContext), varargs...) +} + +// RejectTransitGatewayVpcAttachment mocks base method +func (m *MockEC2API) RejectTransitGatewayVpcAttachment(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachment", arg0) + ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectTransitGatewayVpcAttachment indicates an expected call of RejectTransitGatewayVpcAttachment +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachment), arg0) +} + +// RejectTransitGatewayVpcAttachmentRequest mocks base method +func (m *MockEC2API) RejectTransitGatewayVpcAttachmentRequest(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayVpcAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RejectTransitGatewayVpcAttachmentOutput) + return ret0, ret1 +} + +// RejectTransitGatewayVpcAttachmentRequest indicates an expected call of RejectTransitGatewayVpcAttachmentRequest +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentRequest), arg0) +} + +// RejectTransitGatewayVpcAttachmentWithContext mocks base method +func (m *MockEC2API) RejectTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectTransitGatewayVpcAttachmentWithContext indicates an expected call of RejectTransitGatewayVpcAttachmentWithContext +func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentWithContext), varargs...) +} + +// RejectVpcEndpointConnections mocks base method +func (m *MockEC2API) RejectVpcEndpointConnections(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*ec2.RejectVpcEndpointConnectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectVpcEndpointConnections", arg0) + ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectVpcEndpointConnections indicates an expected call of RejectVpcEndpointConnections +func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnections), arg0) +} + +// RejectVpcEndpointConnectionsRequest mocks base method +func (m *MockEC2API) RejectVpcEndpointConnectionsRequest(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*request.Request, *ec2.RejectVpcEndpointConnectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RejectVpcEndpointConnectionsOutput) + return ret0, ret1 +} + +// RejectVpcEndpointConnectionsRequest indicates an expected call of RejectVpcEndpointConnectionsRequest +func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnectionsRequest), arg0) +} + +// RejectVpcEndpointConnectionsWithContext mocks base method +func (m *MockEC2API) RejectVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.RejectVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.RejectVpcEndpointConnectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectVpcEndpointConnectionsWithContext indicates an expected call of RejectVpcEndpointConnectionsWithContext +func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnectionsWithContext), varargs...) +} + +// RejectVpcPeeringConnection mocks base method +func (m *MockEC2API) RejectVpcPeeringConnection(arg0 *ec2.RejectVpcPeeringConnectionInput) (*ec2.RejectVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectVpcPeeringConnection", arg0) + ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectVpcPeeringConnection indicates an expected call of RejectVpcPeeringConnection +func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnection), arg0) +} + +// RejectVpcPeeringConnectionRequest mocks base method +func (m *MockEC2API) RejectVpcPeeringConnectionRequest(arg0 *ec2.RejectVpcPeeringConnectionInput) (*request.Request, *ec2.RejectVpcPeeringConnectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RejectVpcPeeringConnectionOutput) + return ret0, ret1 +} + +// RejectVpcPeeringConnectionRequest indicates an expected call of RejectVpcPeeringConnectionRequest +func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnectionRequest), arg0) +} + +// RejectVpcPeeringConnectionWithContext mocks base method +func (m *MockEC2API) RejectVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.RejectVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.RejectVpcPeeringConnectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RejectVpcPeeringConnectionWithContext indicates an expected call of RejectVpcPeeringConnectionWithContext +func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnectionWithContext), varargs...) +} + +// ReleaseAddress mocks base method +func (m *MockEC2API) ReleaseAddress(arg0 *ec2.ReleaseAddressInput) (*ec2.ReleaseAddressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReleaseAddress", arg0) + ret0, _ := ret[0].(*ec2.ReleaseAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReleaseAddress indicates an expected call of ReleaseAddress +func (mr *MockEC2APIMockRecorder) ReleaseAddress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddress", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddress), arg0) +} + +// ReleaseAddressRequest mocks base method +func (m *MockEC2API) ReleaseAddressRequest(arg0 *ec2.ReleaseAddressInput) (*request.Request, *ec2.ReleaseAddressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReleaseAddressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReleaseAddressOutput) + return ret0, ret1 +} + +// ReleaseAddressRequest indicates an expected call of ReleaseAddressRequest +func (mr *MockEC2APIMockRecorder) ReleaseAddressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddressRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddressRequest), arg0) +} + +// ReleaseAddressWithContext mocks base method +func (m *MockEC2API) ReleaseAddressWithContext(arg0 context.Context, arg1 *ec2.ReleaseAddressInput, arg2 ...request.Option) (*ec2.ReleaseAddressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReleaseAddressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReleaseAddressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReleaseAddressWithContext indicates an expected call of ReleaseAddressWithContext +func (mr *MockEC2APIMockRecorder) ReleaseAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddressWithContext), varargs...) +} + +// ReleaseHosts mocks base method +func (m *MockEC2API) ReleaseHosts(arg0 *ec2.ReleaseHostsInput) (*ec2.ReleaseHostsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReleaseHosts", arg0) + ret0, _ := ret[0].(*ec2.ReleaseHostsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReleaseHosts indicates an expected call of ReleaseHosts +func (mr *MockEC2APIMockRecorder) ReleaseHosts(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHosts", reflect.TypeOf((*MockEC2API)(nil).ReleaseHosts), arg0) +} + +// ReleaseHostsRequest mocks base method +func (m *MockEC2API) ReleaseHostsRequest(arg0 *ec2.ReleaseHostsInput) (*request.Request, *ec2.ReleaseHostsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReleaseHostsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReleaseHostsOutput) + return ret0, ret1 +} + +// ReleaseHostsRequest indicates an expected call of ReleaseHostsRequest +func (mr *MockEC2APIMockRecorder) ReleaseHostsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseHostsRequest), arg0) +} + +// ReleaseHostsWithContext mocks base method +func (m *MockEC2API) ReleaseHostsWithContext(arg0 context.Context, arg1 *ec2.ReleaseHostsInput, arg2 ...request.Option) (*ec2.ReleaseHostsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReleaseHostsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReleaseHostsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReleaseHostsWithContext indicates an expected call of ReleaseHostsWithContext +func (mr *MockEC2APIMockRecorder) ReleaseHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).ReleaseHostsWithContext), varargs...) +} + +// ReplaceIamInstanceProfileAssociation mocks base method +func (m *MockEC2API) ReplaceIamInstanceProfileAssociation(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociation", arg0) + ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceIamInstanceProfileAssociation indicates an expected call of ReplaceIamInstanceProfileAssociation +func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociation), arg0) +} + +// ReplaceIamInstanceProfileAssociationRequest mocks base method +func (m *MockEC2API) ReplaceIamInstanceProfileAssociationRequest(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*request.Request, *ec2.ReplaceIamInstanceProfileAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReplaceIamInstanceProfileAssociationOutput) + return ret0, ret1 +} + +// ReplaceIamInstanceProfileAssociationRequest indicates an expected call of ReplaceIamInstanceProfileAssociationRequest +func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationRequest), arg0) +} + +// ReplaceIamInstanceProfileAssociationWithContext mocks base method +func (m *MockEC2API) ReplaceIamInstanceProfileAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceIamInstanceProfileAssociationInput, arg2 ...request.Option) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceIamInstanceProfileAssociationWithContext indicates an expected call of ReplaceIamInstanceProfileAssociationWithContext +func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationWithContext), varargs...) +} + +// ReplaceNetworkAclAssociation mocks base method +func (m *MockEC2API) ReplaceNetworkAclAssociation(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*ec2.ReplaceNetworkAclAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociation", arg0) + ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceNetworkAclAssociation indicates an expected call of ReplaceNetworkAclAssociation +func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociation), arg0) +} + +// ReplaceNetworkAclAssociationRequest mocks base method +func (m *MockEC2API) ReplaceNetworkAclAssociationRequest(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*request.Request, *ec2.ReplaceNetworkAclAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReplaceNetworkAclAssociationOutput) + return ret0, ret1 +} + +// ReplaceNetworkAclAssociationRequest indicates an expected call of ReplaceNetworkAclAssociationRequest +func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociationRequest), arg0) +} + +// ReplaceNetworkAclAssociationWithContext mocks base method +func (m *MockEC2API) ReplaceNetworkAclAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceNetworkAclAssociationInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceNetworkAclAssociationWithContext indicates an expected call of ReplaceNetworkAclAssociationWithContext +func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociationWithContext), varargs...) +} + +// ReplaceNetworkAclEntry mocks base method +func (m *MockEC2API) ReplaceNetworkAclEntry(arg0 *ec2.ReplaceNetworkAclEntryInput) (*ec2.ReplaceNetworkAclEntryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceNetworkAclEntry", arg0) + ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceNetworkAclEntry indicates an expected call of ReplaceNetworkAclEntry +func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntry(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntry), arg0) +} + +// ReplaceNetworkAclEntryRequest mocks base method +func (m *MockEC2API) ReplaceNetworkAclEntryRequest(arg0 *ec2.ReplaceNetworkAclEntryInput) (*request.Request, *ec2.ReplaceNetworkAclEntryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReplaceNetworkAclEntryOutput) + return ret0, ret1 +} + +// ReplaceNetworkAclEntryRequest indicates an expected call of ReplaceNetworkAclEntryRequest +func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntryRequest), arg0) +} + +// ReplaceNetworkAclEntryWithContext mocks base method +func (m *MockEC2API) ReplaceNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.ReplaceNetworkAclEntryInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclEntryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceNetworkAclEntryWithContext indicates an expected call of ReplaceNetworkAclEntryWithContext +func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntryWithContext), varargs...) +} + +// ReplaceRoute mocks base method +func (m *MockEC2API) ReplaceRoute(arg0 *ec2.ReplaceRouteInput) (*ec2.ReplaceRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceRoute", arg0) + ret0, _ := ret[0].(*ec2.ReplaceRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceRoute indicates an expected call of ReplaceRoute +func (mr *MockEC2APIMockRecorder) ReplaceRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceRoute), arg0) +} + +// ReplaceRouteRequest mocks base method +func (m *MockEC2API) ReplaceRouteRequest(arg0 *ec2.ReplaceRouteInput) (*request.Request, *ec2.ReplaceRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReplaceRouteOutput) + return ret0, ret1 +} + +// ReplaceRouteRequest indicates an expected call of ReplaceRouteRequest +func (mr *MockEC2APIMockRecorder) ReplaceRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteRequest), arg0) +} + +// ReplaceRouteTableAssociation mocks base method +func (m *MockEC2API) ReplaceRouteTableAssociation(arg0 *ec2.ReplaceRouteTableAssociationInput) (*ec2.ReplaceRouteTableAssociationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceRouteTableAssociation", arg0) + ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceRouteTableAssociation indicates an expected call of ReplaceRouteTableAssociation +func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociation), arg0) +} + +// ReplaceRouteTableAssociationRequest mocks base method +func (m *MockEC2API) ReplaceRouteTableAssociationRequest(arg0 *ec2.ReplaceRouteTableAssociationInput) (*request.Request, *ec2.ReplaceRouteTableAssociationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReplaceRouteTableAssociationOutput) + return ret0, ret1 +} + +// ReplaceRouteTableAssociationRequest indicates an expected call of ReplaceRouteTableAssociationRequest +func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociationRequest), arg0) +} + +// ReplaceRouteTableAssociationWithContext mocks base method +func (m *MockEC2API) ReplaceRouteTableAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceRouteTableAssociationInput, arg2 ...request.Option) (*ec2.ReplaceRouteTableAssociationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceRouteTableAssociationWithContext indicates an expected call of ReplaceRouteTableAssociationWithContext +func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociationWithContext), varargs...) +} + +// ReplaceRouteWithContext mocks base method +func (m *MockEC2API) ReplaceRouteWithContext(arg0 context.Context, arg1 *ec2.ReplaceRouteInput, arg2 ...request.Option) (*ec2.ReplaceRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReplaceRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReplaceRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceRouteWithContext indicates an expected call of ReplaceRouteWithContext +func (mr *MockEC2APIMockRecorder) ReplaceRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteWithContext), varargs...) +} + +// ReplaceTransitGatewayRoute mocks base method +func (m *MockEC2API) ReplaceTransitGatewayRoute(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*ec2.ReplaceTransitGatewayRouteOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceTransitGatewayRoute", arg0) + ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceTransitGatewayRoute indicates an expected call of ReplaceTransitGatewayRoute +func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRoute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRoute), arg0) +} + +// ReplaceTransitGatewayRouteRequest mocks base method +func (m *MockEC2API) ReplaceTransitGatewayRouteRequest(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*request.Request, *ec2.ReplaceTransitGatewayRouteOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReplaceTransitGatewayRouteOutput) + return ret0, ret1 +} + +// ReplaceTransitGatewayRouteRequest indicates an expected call of ReplaceTransitGatewayRouteRequest +func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteRequest), arg0) +} + +// ReplaceTransitGatewayRouteWithContext mocks base method +func (m *MockEC2API) ReplaceTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.ReplaceTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.ReplaceTransitGatewayRouteOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplaceTransitGatewayRouteWithContext indicates an expected call of ReplaceTransitGatewayRouteWithContext +func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteWithContext), varargs...) +} + +// ReportInstanceStatus mocks base method +func (m *MockEC2API) ReportInstanceStatus(arg0 *ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReportInstanceStatus", arg0) + ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReportInstanceStatus indicates an expected call of ReportInstanceStatus +func (mr *MockEC2APIMockRecorder) ReportInstanceStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatus), arg0) +} + +// ReportInstanceStatusRequest mocks base method +func (m *MockEC2API) ReportInstanceStatusRequest(arg0 *ec2.ReportInstanceStatusInput) (*request.Request, *ec2.ReportInstanceStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReportInstanceStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ReportInstanceStatusOutput) + return ret0, ret1 +} + +// ReportInstanceStatusRequest indicates an expected call of ReportInstanceStatusRequest +func (mr *MockEC2APIMockRecorder) ReportInstanceStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatusRequest), arg0) +} + +// ReportInstanceStatusWithContext mocks base method +func (m *MockEC2API) ReportInstanceStatusWithContext(arg0 context.Context, arg1 *ec2.ReportInstanceStatusInput, arg2 ...request.Option) (*ec2.ReportInstanceStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReportInstanceStatusWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReportInstanceStatusWithContext indicates an expected call of ReportInstanceStatusWithContext +func (mr *MockEC2APIMockRecorder) ReportInstanceStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatusWithContext), varargs...) +} + +// RequestSpotFleet mocks base method +func (m *MockEC2API) RequestSpotFleet(arg0 *ec2.RequestSpotFleetInput) (*ec2.RequestSpotFleetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestSpotFleet", arg0) + ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestSpotFleet indicates an expected call of RequestSpotFleet +func (mr *MockEC2APIMockRecorder) RequestSpotFleet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleet", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleet), arg0) +} + +// RequestSpotFleetRequest mocks base method +func (m *MockEC2API) RequestSpotFleetRequest(arg0 *ec2.RequestSpotFleetInput) (*request.Request, *ec2.RequestSpotFleetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestSpotFleetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RequestSpotFleetOutput) + return ret0, ret1 +} + +// RequestSpotFleetRequest indicates an expected call of RequestSpotFleetRequest +func (mr *MockEC2APIMockRecorder) RequestSpotFleetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleetRequest), arg0) +} + +// RequestSpotFleetWithContext mocks base method +func (m *MockEC2API) RequestSpotFleetWithContext(arg0 context.Context, arg1 *ec2.RequestSpotFleetInput, arg2 ...request.Option) (*ec2.RequestSpotFleetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestSpotFleetWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestSpotFleetWithContext indicates an expected call of RequestSpotFleetWithContext +func (mr *MockEC2APIMockRecorder) RequestSpotFleetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleetWithContext), varargs...) +} + +// RequestSpotInstances mocks base method +func (m *MockEC2API) RequestSpotInstances(arg0 *ec2.RequestSpotInstancesInput) (*ec2.RequestSpotInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestSpotInstances", arg0) + ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestSpotInstances indicates an expected call of RequestSpotInstances +func (mr *MockEC2APIMockRecorder) RequestSpotInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstances", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstances), arg0) +} + +// RequestSpotInstancesRequest mocks base method +func (m *MockEC2API) RequestSpotInstancesRequest(arg0 *ec2.RequestSpotInstancesInput) (*request.Request, *ec2.RequestSpotInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestSpotInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RequestSpotInstancesOutput) + return ret0, ret1 +} + +// RequestSpotInstancesRequest indicates an expected call of RequestSpotInstancesRequest +func (mr *MockEC2APIMockRecorder) RequestSpotInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesRequest), arg0) +} + +// RequestSpotInstancesWithContext mocks base method +func (m *MockEC2API) RequestSpotInstancesWithContext(arg0 context.Context, arg1 *ec2.RequestSpotInstancesInput, arg2 ...request.Option) (*ec2.RequestSpotInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestSpotInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestSpotInstancesWithContext indicates an expected call of RequestSpotInstancesWithContext +func (mr *MockEC2APIMockRecorder) RequestSpotInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesWithContext), varargs...) +} + +// ResetEbsDefaultKmsKeyId mocks base method +func (m *MockEC2API) ResetEbsDefaultKmsKeyId(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyId", arg0) + ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetEbsDefaultKmsKeyId indicates an expected call of ResetEbsDefaultKmsKeyId +func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyId), arg0) +} + +// ResetEbsDefaultKmsKeyIdRequest mocks base method +func (m *MockEC2API) ResetEbsDefaultKmsKeyIdRequest(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ResetEbsDefaultKmsKeyIdOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ResetEbsDefaultKmsKeyIdOutput) + return ret0, ret1 +} + +// ResetEbsDefaultKmsKeyIdRequest indicates an expected call of ResetEbsDefaultKmsKeyIdRequest +func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdRequest), arg0) +} + +// ResetEbsDefaultKmsKeyIdWithContext mocks base method +func (m *MockEC2API) ResetEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.ResetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetEbsDefaultKmsKeyIdWithContext indicates an expected call of ResetEbsDefaultKmsKeyIdWithContext +func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdWithContext), varargs...) +} + +// ResetFpgaImageAttribute mocks base method +func (m *MockEC2API) ResetFpgaImageAttribute(arg0 *ec2.ResetFpgaImageAttributeInput) (*ec2.ResetFpgaImageAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetFpgaImageAttribute", arg0) + ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetFpgaImageAttribute indicates an expected call of ResetFpgaImageAttribute +func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttribute), arg0) +} + +// ResetFpgaImageAttributeRequest mocks base method +func (m *MockEC2API) ResetFpgaImageAttributeRequest(arg0 *ec2.ResetFpgaImageAttributeInput) (*request.Request, *ec2.ResetFpgaImageAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetFpgaImageAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ResetFpgaImageAttributeOutput) + return ret0, ret1 +} + +// ResetFpgaImageAttributeRequest indicates an expected call of ResetFpgaImageAttributeRequest +func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttributeRequest), arg0) +} + +// ResetFpgaImageAttributeWithContext mocks base method +func (m *MockEC2API) ResetFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ResetFpgaImageAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetFpgaImageAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetFpgaImageAttributeWithContext indicates an expected call of ResetFpgaImageAttributeWithContext +func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttributeWithContext), varargs...) +} + +// ResetImageAttribute mocks base method +func (m *MockEC2API) ResetImageAttribute(arg0 *ec2.ResetImageAttributeInput) (*ec2.ResetImageAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetImageAttribute", arg0) + ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetImageAttribute indicates an expected call of ResetImageAttribute +func (mr *MockEC2APIMockRecorder) ResetImageAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttribute), arg0) +} + +// ResetImageAttributeRequest mocks base method +func (m *MockEC2API) ResetImageAttributeRequest(arg0 *ec2.ResetImageAttributeInput) (*request.Request, *ec2.ResetImageAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetImageAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ResetImageAttributeOutput) + return ret0, ret1 +} + +// ResetImageAttributeRequest indicates an expected call of ResetImageAttributeRequest +func (mr *MockEC2APIMockRecorder) ResetImageAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttributeRequest), arg0) +} + +// ResetImageAttributeWithContext mocks base method +func (m *MockEC2API) ResetImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetImageAttributeInput, arg2 ...request.Option) (*ec2.ResetImageAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetImageAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetImageAttributeWithContext indicates an expected call of ResetImageAttributeWithContext +func (mr *MockEC2APIMockRecorder) ResetImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttributeWithContext), varargs...) +} + +// ResetInstanceAttribute mocks base method +func (m *MockEC2API) ResetInstanceAttribute(arg0 *ec2.ResetInstanceAttributeInput) (*ec2.ResetInstanceAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetInstanceAttribute", arg0) + ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetInstanceAttribute indicates an expected call of ResetInstanceAttribute +func (mr *MockEC2APIMockRecorder) ResetInstanceAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttribute), arg0) +} + +// ResetInstanceAttributeRequest mocks base method +func (m *MockEC2API) ResetInstanceAttributeRequest(arg0 *ec2.ResetInstanceAttributeInput) (*request.Request, *ec2.ResetInstanceAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetInstanceAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ResetInstanceAttributeOutput) + return ret0, ret1 +} + +// ResetInstanceAttributeRequest indicates an expected call of ResetInstanceAttributeRequest +func (mr *MockEC2APIMockRecorder) ResetInstanceAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttributeRequest), arg0) +} + +// ResetInstanceAttributeWithContext mocks base method +func (m *MockEC2API) ResetInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetInstanceAttributeInput, arg2 ...request.Option) (*ec2.ResetInstanceAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetInstanceAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetInstanceAttributeWithContext indicates an expected call of ResetInstanceAttributeWithContext +func (mr *MockEC2APIMockRecorder) ResetInstanceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttributeWithContext), varargs...) +} + +// ResetNetworkInterfaceAttribute mocks base method +func (m *MockEC2API) ResetNetworkInterfaceAttribute(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*ec2.ResetNetworkInterfaceAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttribute", arg0) + ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetNetworkInterfaceAttribute indicates an expected call of ResetNetworkInterfaceAttribute +func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttribute), arg0) +} + +// ResetNetworkInterfaceAttributeRequest mocks base method +func (m *MockEC2API) ResetNetworkInterfaceAttributeRequest(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*request.Request, *ec2.ResetNetworkInterfaceAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ResetNetworkInterfaceAttributeOutput) + return ret0, ret1 +} + +// ResetNetworkInterfaceAttributeRequest indicates an expected call of ResetNetworkInterfaceAttributeRequest +func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttributeRequest), arg0) +} + +// ResetNetworkInterfaceAttributeWithContext mocks base method +func (m *MockEC2API) ResetNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ResetNetworkInterfaceAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetNetworkInterfaceAttributeWithContext indicates an expected call of ResetNetworkInterfaceAttributeWithContext +func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttributeWithContext), varargs...) +} + +// ResetSnapshotAttribute mocks base method +func (m *MockEC2API) ResetSnapshotAttribute(arg0 *ec2.ResetSnapshotAttributeInput) (*ec2.ResetSnapshotAttributeOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetSnapshotAttribute", arg0) + ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetSnapshotAttribute indicates an expected call of ResetSnapshotAttribute +func (mr *MockEC2APIMockRecorder) ResetSnapshotAttribute(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttribute), arg0) +} + +// ResetSnapshotAttributeRequest mocks base method +func (m *MockEC2API) ResetSnapshotAttributeRequest(arg0 *ec2.ResetSnapshotAttributeInput) (*request.Request, *ec2.ResetSnapshotAttributeOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetSnapshotAttributeRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.ResetSnapshotAttributeOutput) + return ret0, ret1 +} + +// ResetSnapshotAttributeRequest indicates an expected call of ResetSnapshotAttributeRequest +func (mr *MockEC2APIMockRecorder) ResetSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttributeRequest), arg0) +} + +// ResetSnapshotAttributeWithContext mocks base method +func (m *MockEC2API) ResetSnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetSnapshotAttributeInput, arg2 ...request.Option) (*ec2.ResetSnapshotAttributeOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetSnapshotAttributeWithContext", varargs...) + ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetSnapshotAttributeWithContext indicates an expected call of ResetSnapshotAttributeWithContext +func (mr *MockEC2APIMockRecorder) ResetSnapshotAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttributeWithContext), varargs...) +} + +// RestoreAddressToClassic mocks base method +func (m *MockEC2API) RestoreAddressToClassic(arg0 *ec2.RestoreAddressToClassicInput) (*ec2.RestoreAddressToClassicOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreAddressToClassic", arg0) + ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreAddressToClassic indicates an expected call of RestoreAddressToClassic +func (mr *MockEC2APIMockRecorder) RestoreAddressToClassic(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassic", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassic), arg0) +} + +// RestoreAddressToClassicRequest mocks base method +func (m *MockEC2API) RestoreAddressToClassicRequest(arg0 *ec2.RestoreAddressToClassicInput) (*request.Request, *ec2.RestoreAddressToClassicOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreAddressToClassicRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RestoreAddressToClassicOutput) + return ret0, ret1 +} + +// RestoreAddressToClassicRequest indicates an expected call of RestoreAddressToClassicRequest +func (mr *MockEC2APIMockRecorder) RestoreAddressToClassicRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassicRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassicRequest), arg0) +} + +// RestoreAddressToClassicWithContext mocks base method +func (m *MockEC2API) RestoreAddressToClassicWithContext(arg0 context.Context, arg1 *ec2.RestoreAddressToClassicInput, arg2 ...request.Option) (*ec2.RestoreAddressToClassicOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RestoreAddressToClassicWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreAddressToClassicWithContext indicates an expected call of RestoreAddressToClassicWithContext +func (mr *MockEC2APIMockRecorder) RestoreAddressToClassicWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassicWithContext", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassicWithContext), varargs...) +} + +// RestoreManagedPrefixListVersion mocks base method +func (m *MockEC2API) RestoreManagedPrefixListVersion(arg0 *ec2.RestoreManagedPrefixListVersionInput) (*ec2.RestoreManagedPrefixListVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersion", arg0) + ret0, _ := ret[0].(*ec2.RestoreManagedPrefixListVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreManagedPrefixListVersion indicates an expected call of RestoreManagedPrefixListVersion +func (mr *MockEC2APIMockRecorder) RestoreManagedPrefixListVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersion", reflect.TypeOf((*MockEC2API)(nil).RestoreManagedPrefixListVersion), arg0) +} + +// RestoreManagedPrefixListVersionRequest mocks base method +func (m *MockEC2API) RestoreManagedPrefixListVersionRequest(arg0 *ec2.RestoreManagedPrefixListVersionInput) (*request.Request, *ec2.RestoreManagedPrefixListVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RestoreManagedPrefixListVersionOutput) + return ret0, ret1 +} + +// RestoreManagedPrefixListVersionRequest indicates an expected call of RestoreManagedPrefixListVersionRequest +func (mr *MockEC2APIMockRecorder) RestoreManagedPrefixListVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersionRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreManagedPrefixListVersionRequest), arg0) +} + +// RestoreManagedPrefixListVersionWithContext mocks base method +func (m *MockEC2API) RestoreManagedPrefixListVersionWithContext(arg0 context.Context, arg1 *ec2.RestoreManagedPrefixListVersionInput, arg2 ...request.Option) (*ec2.RestoreManagedPrefixListVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersionWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RestoreManagedPrefixListVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreManagedPrefixListVersionWithContext indicates an expected call of RestoreManagedPrefixListVersionWithContext +func (mr *MockEC2APIMockRecorder) RestoreManagedPrefixListVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersionWithContext", reflect.TypeOf((*MockEC2API)(nil).RestoreManagedPrefixListVersionWithContext), varargs...) +} + +// RevokeClientVpnIngress mocks base method +func (m *MockEC2API) RevokeClientVpnIngress(arg0 *ec2.RevokeClientVpnIngressInput) (*ec2.RevokeClientVpnIngressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RevokeClientVpnIngress", arg0) + ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeClientVpnIngress indicates an expected call of RevokeClientVpnIngress +func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngress), arg0) +} + +// RevokeClientVpnIngressRequest mocks base method +func (m *MockEC2API) RevokeClientVpnIngressRequest(arg0 *ec2.RevokeClientVpnIngressInput) (*request.Request, *ec2.RevokeClientVpnIngressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RevokeClientVpnIngressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RevokeClientVpnIngressOutput) + return ret0, ret1 +} + +// RevokeClientVpnIngressRequest indicates an expected call of RevokeClientVpnIngressRequest +func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngressRequest), arg0) +} + +// RevokeClientVpnIngressWithContext mocks base method +func (m *MockEC2API) RevokeClientVpnIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeClientVpnIngressInput, arg2 ...request.Option) (*ec2.RevokeClientVpnIngressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RevokeClientVpnIngressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeClientVpnIngressWithContext indicates an expected call of RevokeClientVpnIngressWithContext +func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngressWithContext), varargs...) +} + +// RevokeSecurityGroupEgress mocks base method +func (m *MockEC2API) RevokeSecurityGroupEgress(arg0 *ec2.RevokeSecurityGroupEgressInput) (*ec2.RevokeSecurityGroupEgressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RevokeSecurityGroupEgress", arg0) + ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeSecurityGroupEgress indicates an expected call of RevokeSecurityGroupEgress +func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgress), arg0) +} + +// RevokeSecurityGroupEgressRequest mocks base method +func (m *MockEC2API) RevokeSecurityGroupEgressRequest(arg0 *ec2.RevokeSecurityGroupEgressInput) (*request.Request, *ec2.RevokeSecurityGroupEgressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RevokeSecurityGroupEgressOutput) + return ret0, ret1 +} + +// RevokeSecurityGroupEgressRequest indicates an expected call of RevokeSecurityGroupEgressRequest +func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgressRequest), arg0) +} + +// RevokeSecurityGroupEgressWithContext mocks base method +func (m *MockEC2API) RevokeSecurityGroupEgressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupEgressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeSecurityGroupEgressWithContext indicates an expected call of RevokeSecurityGroupEgressWithContext +func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgressWithContext), varargs...) +} + +// RevokeSecurityGroupIngress mocks base method +func (m *MockEC2API) RevokeSecurityGroupIngress(arg0 *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RevokeSecurityGroupIngress", arg0) + ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeSecurityGroupIngress indicates an expected call of RevokeSecurityGroupIngress +func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngress), arg0) +} + +// RevokeSecurityGroupIngressRequest mocks base method +func (m *MockEC2API) RevokeSecurityGroupIngressRequest(arg0 *ec2.RevokeSecurityGroupIngressInput) (*request.Request, *ec2.RevokeSecurityGroupIngressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RevokeSecurityGroupIngressOutput) + return ret0, ret1 +} + +// RevokeSecurityGroupIngressRequest indicates an expected call of RevokeSecurityGroupIngressRequest +func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngressRequest), arg0) +} + +// RevokeSecurityGroupIngressWithContext mocks base method +func (m *MockEC2API) RevokeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupIngressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeSecurityGroupIngressWithContext indicates an expected call of RevokeSecurityGroupIngressWithContext +func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngressWithContext), varargs...) +} + +// RunInstances mocks base method +func (m *MockEC2API) RunInstances(arg0 *ec2.RunInstancesInput) (*ec2.Reservation, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RunInstances", arg0) + ret0, _ := ret[0].(*ec2.Reservation) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RunInstances indicates an expected call of RunInstances +func (mr *MockEC2APIMockRecorder) RunInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstances", reflect.TypeOf((*MockEC2API)(nil).RunInstances), arg0) +} + +// RunInstancesRequest mocks base method +func (m *MockEC2API) RunInstancesRequest(arg0 *ec2.RunInstancesInput) (*request.Request, *ec2.Reservation) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RunInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.Reservation) + return ret0, ret1 +} + +// RunInstancesRequest indicates an expected call of RunInstancesRequest +func (mr *MockEC2APIMockRecorder) RunInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunInstancesRequest), arg0) +} + +// RunInstancesWithContext mocks base method +func (m *MockEC2API) RunInstancesWithContext(arg0 context.Context, arg1 *ec2.RunInstancesInput, arg2 ...request.Option) (*ec2.Reservation, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RunInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.Reservation) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RunInstancesWithContext indicates an expected call of RunInstancesWithContext +func (mr *MockEC2APIMockRecorder) RunInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RunInstancesWithContext), varargs...) +} + +// RunScheduledInstances mocks base method +func (m *MockEC2API) RunScheduledInstances(arg0 *ec2.RunScheduledInstancesInput) (*ec2.RunScheduledInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RunScheduledInstances", arg0) + ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RunScheduledInstances indicates an expected call of RunScheduledInstances +func (mr *MockEC2APIMockRecorder) RunScheduledInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstances), arg0) +} + +// RunScheduledInstancesRequest mocks base method +func (m *MockEC2API) RunScheduledInstancesRequest(arg0 *ec2.RunScheduledInstancesInput) (*request.Request, *ec2.RunScheduledInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RunScheduledInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.RunScheduledInstancesOutput) + return ret0, ret1 +} + +// RunScheduledInstancesRequest indicates an expected call of RunScheduledInstancesRequest +func (mr *MockEC2APIMockRecorder) RunScheduledInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstancesRequest), arg0) +} + +// RunScheduledInstancesWithContext mocks base method +func (m *MockEC2API) RunScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.RunScheduledInstancesInput, arg2 ...request.Option) (*ec2.RunScheduledInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RunScheduledInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RunScheduledInstancesWithContext indicates an expected call of RunScheduledInstancesWithContext +func (mr *MockEC2APIMockRecorder) RunScheduledInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstancesWithContext), varargs...) +} + +// SearchLocalGatewayRoutes mocks base method +func (m *MockEC2API) SearchLocalGatewayRoutes(arg0 *ec2.SearchLocalGatewayRoutesInput) (*ec2.SearchLocalGatewayRoutesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchLocalGatewayRoutes", arg0) + ret0, _ := ret[0].(*ec2.SearchLocalGatewayRoutesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchLocalGatewayRoutes indicates an expected call of SearchLocalGatewayRoutes +func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutes), arg0) +} + +// SearchLocalGatewayRoutesPages mocks base method +func (m *MockEC2API) SearchLocalGatewayRoutesPages(arg0 *ec2.SearchLocalGatewayRoutesInput, arg1 func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SearchLocalGatewayRoutesPages indicates an expected call of SearchLocalGatewayRoutesPages +func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesPages", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesPages), arg0, arg1) +} + +// SearchLocalGatewayRoutesPagesWithContext mocks base method +func (m *MockEC2API) SearchLocalGatewayRoutesPagesWithContext(arg0 context.Context, arg1 *ec2.SearchLocalGatewayRoutesInput, arg2 func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SearchLocalGatewayRoutesPagesWithContext indicates an expected call of SearchLocalGatewayRoutesPagesWithContext +func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesPagesWithContext), varargs...) +} + +// SearchLocalGatewayRoutesRequest mocks base method +func (m *MockEC2API) SearchLocalGatewayRoutesRequest(arg0 *ec2.SearchLocalGatewayRoutesInput) (*request.Request, *ec2.SearchLocalGatewayRoutesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.SearchLocalGatewayRoutesOutput) + return ret0, ret1 +} + +// SearchLocalGatewayRoutesRequest indicates an expected call of SearchLocalGatewayRoutesRequest +func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesRequest), arg0) +} + +// SearchLocalGatewayRoutesWithContext mocks base method +func (m *MockEC2API) SearchLocalGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.SearchLocalGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchLocalGatewayRoutesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.SearchLocalGatewayRoutesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchLocalGatewayRoutesWithContext indicates an expected call of SearchLocalGatewayRoutesWithContext +func (mr *MockEC2APIMockRecorder) SearchLocalGatewayRoutesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesWithContext), varargs...) +} + +// SearchTransitGatewayMulticastGroups mocks base method +func (m *MockEC2API) SearchTransitGatewayMulticastGroups(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroups", arg0) + ret0, _ := ret[0].(*ec2.SearchTransitGatewayMulticastGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchTransitGatewayMulticastGroups indicates an expected call of SearchTransitGatewayMulticastGroups +func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroups", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroups), arg0) +} + +// SearchTransitGatewayMulticastGroupsPages mocks base method +func (m *MockEC2API) SearchTransitGatewayMulticastGroupsPages(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput, arg1 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SearchTransitGatewayMulticastGroupsPages indicates an expected call of SearchTransitGatewayMulticastGroupsPages +func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsPages", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsPages), arg0, arg1) +} + +// SearchTransitGatewayMulticastGroupsPagesWithContext mocks base method +func (m *MockEC2API) SearchTransitGatewayMulticastGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayMulticastGroupsInput, arg2 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SearchTransitGatewayMulticastGroupsPagesWithContext indicates an expected call of SearchTransitGatewayMulticastGroupsPagesWithContext +func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsPagesWithContext), varargs...) +} + +// SearchTransitGatewayMulticastGroupsRequest mocks base method +func (m *MockEC2API) SearchTransitGatewayMulticastGroupsRequest(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*request.Request, *ec2.SearchTransitGatewayMulticastGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.SearchTransitGatewayMulticastGroupsOutput) + return ret0, ret1 +} + +// SearchTransitGatewayMulticastGroupsRequest indicates an expected call of SearchTransitGatewayMulticastGroupsRequest +func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsRequest), arg0) +} + +// SearchTransitGatewayMulticastGroupsWithContext mocks base method +func (m *MockEC2API) SearchTransitGatewayMulticastGroupsWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayMulticastGroupsInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.SearchTransitGatewayMulticastGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchTransitGatewayMulticastGroupsWithContext indicates an expected call of SearchTransitGatewayMulticastGroupsWithContext +func (mr *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsWithContext), varargs...) +} + +// SearchTransitGatewayRoutes mocks base method +func (m *MockEC2API) SearchTransitGatewayRoutes(arg0 *ec2.SearchTransitGatewayRoutesInput) (*ec2.SearchTransitGatewayRoutesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchTransitGatewayRoutes", arg0) + ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchTransitGatewayRoutes indicates an expected call of SearchTransitGatewayRoutes +func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutes), arg0) +} + +// SearchTransitGatewayRoutesRequest mocks base method +func (m *MockEC2API) SearchTransitGatewayRoutesRequest(arg0 *ec2.SearchTransitGatewayRoutesInput) (*request.Request, *ec2.SearchTransitGatewayRoutesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.SearchTransitGatewayRoutesOutput) + return ret0, ret1 +} + +// SearchTransitGatewayRoutesRequest indicates an expected call of SearchTransitGatewayRoutesRequest +func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutesRequest), arg0) +} + +// SearchTransitGatewayRoutesWithContext mocks base method +func (m *MockEC2API) SearchTransitGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayRoutesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchTransitGatewayRoutesWithContext indicates an expected call of SearchTransitGatewayRoutesWithContext +func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutesWithContext), varargs...) +} + +// SendDiagnosticInterrupt mocks base method +func (m *MockEC2API) SendDiagnosticInterrupt(arg0 *ec2.SendDiagnosticInterruptInput) (*ec2.SendDiagnosticInterruptOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendDiagnosticInterrupt", arg0) + ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendDiagnosticInterrupt indicates an expected call of SendDiagnosticInterrupt +func (mr *MockEC2APIMockRecorder) SendDiagnosticInterrupt(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterrupt", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterrupt), arg0) +} + +// SendDiagnosticInterruptRequest mocks base method +func (m *MockEC2API) SendDiagnosticInterruptRequest(arg0 *ec2.SendDiagnosticInterruptInput) (*request.Request, *ec2.SendDiagnosticInterruptOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendDiagnosticInterruptRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.SendDiagnosticInterruptOutput) + return ret0, ret1 +} + +// SendDiagnosticInterruptRequest indicates an expected call of SendDiagnosticInterruptRequest +func (mr *MockEC2APIMockRecorder) SendDiagnosticInterruptRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterruptRequest", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterruptRequest), arg0) +} + +// SendDiagnosticInterruptWithContext mocks base method +func (m *MockEC2API) SendDiagnosticInterruptWithContext(arg0 context.Context, arg1 *ec2.SendDiagnosticInterruptInput, arg2 ...request.Option) (*ec2.SendDiagnosticInterruptOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendDiagnosticInterruptWithContext", varargs...) + ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendDiagnosticInterruptWithContext indicates an expected call of SendDiagnosticInterruptWithContext +func (mr *MockEC2APIMockRecorder) SendDiagnosticInterruptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterruptWithContext", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterruptWithContext), varargs...) +} + +// StartInstances mocks base method +func (m *MockEC2API) StartInstances(arg0 *ec2.StartInstancesInput) (*ec2.StartInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartInstances", arg0) + ret0, _ := ret[0].(*ec2.StartInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartInstances indicates an expected call of StartInstances +func (mr *MockEC2APIMockRecorder) StartInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstances", reflect.TypeOf((*MockEC2API)(nil).StartInstances), arg0) +} + +// StartInstancesRequest mocks base method +func (m *MockEC2API) StartInstancesRequest(arg0 *ec2.StartInstancesInput) (*request.Request, *ec2.StartInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.StartInstancesOutput) + return ret0, ret1 +} + +// StartInstancesRequest indicates an expected call of StartInstancesRequest +func (mr *MockEC2APIMockRecorder) StartInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StartInstancesRequest), arg0) +} + +// StartInstancesWithContext mocks base method +func (m *MockEC2API) StartInstancesWithContext(arg0 context.Context, arg1 *ec2.StartInstancesInput, arg2 ...request.Option) (*ec2.StartInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.StartInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartInstancesWithContext indicates an expected call of StartInstancesWithContext +func (mr *MockEC2APIMockRecorder) StartInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).StartInstancesWithContext), varargs...) +} + +// StartVpcEndpointServicePrivateDnsVerification mocks base method +func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerification(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerification", arg0) + ret0, _ := ret[0].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartVpcEndpointServicePrivateDnsVerification indicates an expected call of StartVpcEndpointServicePrivateDnsVerification +func (mr *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerification", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerification), arg0) +} + +// StartVpcEndpointServicePrivateDnsVerificationRequest mocks base method +func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*request.Request, *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) + return ret0, ret1 +} + +// StartVpcEndpointServicePrivateDnsVerificationRequest indicates an expected call of StartVpcEndpointServicePrivateDnsVerificationRequest +func (mr *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerificationRequest", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerificationRequest), arg0) +} + +// StartVpcEndpointServicePrivateDnsVerificationWithContext mocks base method +func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerificationWithContext(arg0 context.Context, arg1 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, arg2 ...request.Option) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerificationWithContext", varargs...) + ret0, _ := ret[0].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartVpcEndpointServicePrivateDnsVerificationWithContext indicates an expected call of StartVpcEndpointServicePrivateDnsVerificationWithContext +func (mr *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerificationWithContext", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerificationWithContext), varargs...) +} + +// StopInstances mocks base method +func (m *MockEC2API) StopInstances(arg0 *ec2.StopInstancesInput) (*ec2.StopInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopInstances", arg0) + ret0, _ := ret[0].(*ec2.StopInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopInstances indicates an expected call of StopInstances +func (mr *MockEC2APIMockRecorder) StopInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstances", reflect.TypeOf((*MockEC2API)(nil).StopInstances), arg0) +} + +// StopInstancesRequest mocks base method +func (m *MockEC2API) StopInstancesRequest(arg0 *ec2.StopInstancesInput) (*request.Request, *ec2.StopInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.StopInstancesOutput) + return ret0, ret1 +} + +// StopInstancesRequest indicates an expected call of StopInstancesRequest +func (mr *MockEC2APIMockRecorder) StopInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StopInstancesRequest), arg0) +} + +// StopInstancesWithContext mocks base method +func (m *MockEC2API) StopInstancesWithContext(arg0 context.Context, arg1 *ec2.StopInstancesInput, arg2 ...request.Option) (*ec2.StopInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StopInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.StopInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopInstancesWithContext indicates an expected call of StopInstancesWithContext +func (mr *MockEC2APIMockRecorder) StopInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).StopInstancesWithContext), varargs...) +} + +// TerminateClientVpnConnections mocks base method +func (m *MockEC2API) TerminateClientVpnConnections(arg0 *ec2.TerminateClientVpnConnectionsInput) (*ec2.TerminateClientVpnConnectionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TerminateClientVpnConnections", arg0) + ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TerminateClientVpnConnections indicates an expected call of TerminateClientVpnConnections +func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnections), arg0) +} + +// TerminateClientVpnConnectionsRequest mocks base method +func (m *MockEC2API) TerminateClientVpnConnectionsRequest(arg0 *ec2.TerminateClientVpnConnectionsInput) (*request.Request, *ec2.TerminateClientVpnConnectionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.TerminateClientVpnConnectionsOutput) + return ret0, ret1 +} + +// TerminateClientVpnConnectionsRequest indicates an expected call of TerminateClientVpnConnectionsRequest +func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnectionsRequest), arg0) +} + +// TerminateClientVpnConnectionsWithContext mocks base method +func (m *MockEC2API) TerminateClientVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.TerminateClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.TerminateClientVpnConnectionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsWithContext", varargs...) + ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TerminateClientVpnConnectionsWithContext indicates an expected call of TerminateClientVpnConnectionsWithContext +func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnectionsWithContext), varargs...) +} + +// TerminateInstances mocks base method +func (m *MockEC2API) TerminateInstances(arg0 *ec2.TerminateInstancesInput) (*ec2.TerminateInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TerminateInstances", arg0) + ret0, _ := ret[0].(*ec2.TerminateInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TerminateInstances indicates an expected call of TerminateInstances +func (mr *MockEC2APIMockRecorder) TerminateInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstances", reflect.TypeOf((*MockEC2API)(nil).TerminateInstances), arg0) +} + +// TerminateInstancesRequest mocks base method +func (m *MockEC2API) TerminateInstancesRequest(arg0 *ec2.TerminateInstancesInput) (*request.Request, *ec2.TerminateInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TerminateInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.TerminateInstancesOutput) + return ret0, ret1 +} + +// TerminateInstancesRequest indicates an expected call of TerminateInstancesRequest +func (mr *MockEC2APIMockRecorder) TerminateInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateInstancesRequest), arg0) +} + +// TerminateInstancesWithContext mocks base method +func (m *MockEC2API) TerminateInstancesWithContext(arg0 context.Context, arg1 *ec2.TerminateInstancesInput, arg2 ...request.Option) (*ec2.TerminateInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TerminateInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.TerminateInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TerminateInstancesWithContext indicates an expected call of TerminateInstancesWithContext +func (mr *MockEC2APIMockRecorder) TerminateInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).TerminateInstancesWithContext), varargs...) +} + +// UnassignIpv6Addresses mocks base method +func (m *MockEC2API) UnassignIpv6Addresses(arg0 *ec2.UnassignIpv6AddressesInput) (*ec2.UnassignIpv6AddressesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnassignIpv6Addresses", arg0) + ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnassignIpv6Addresses indicates an expected call of UnassignIpv6Addresses +func (mr *MockEC2APIMockRecorder) UnassignIpv6Addresses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6Addresses), arg0) +} + +// UnassignIpv6AddressesRequest mocks base method +func (m *MockEC2API) UnassignIpv6AddressesRequest(arg0 *ec2.UnassignIpv6AddressesInput) (*request.Request, *ec2.UnassignIpv6AddressesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnassignIpv6AddressesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.UnassignIpv6AddressesOutput) + return ret0, ret1 +} + +// UnassignIpv6AddressesRequest indicates an expected call of UnassignIpv6AddressesRequest +func (mr *MockEC2APIMockRecorder) UnassignIpv6AddressesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6AddressesRequest), arg0) +} + +// UnassignIpv6AddressesWithContext mocks base method +func (m *MockEC2API) UnassignIpv6AddressesWithContext(arg0 context.Context, arg1 *ec2.UnassignIpv6AddressesInput, arg2 ...request.Option) (*ec2.UnassignIpv6AddressesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnassignIpv6AddressesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnassignIpv6AddressesWithContext indicates an expected call of UnassignIpv6AddressesWithContext +func (mr *MockEC2APIMockRecorder) UnassignIpv6AddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6AddressesWithContext), varargs...) +} + +// UnassignPrivateIpAddresses mocks base method +func (m *MockEC2API) UnassignPrivateIpAddresses(arg0 *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnassignPrivateIpAddresses", arg0) + ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnassignPrivateIpAddresses indicates an expected call of UnassignPrivateIpAddresses +func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddresses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddresses), arg0) +} + +// UnassignPrivateIpAddressesRequest mocks base method +func (m *MockEC2API) UnassignPrivateIpAddressesRequest(arg0 *ec2.UnassignPrivateIpAddressesInput) (*request.Request, *ec2.UnassignPrivateIpAddressesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.UnassignPrivateIpAddressesOutput) + return ret0, ret1 +} + +// UnassignPrivateIpAddressesRequest indicates an expected call of UnassignPrivateIpAddressesRequest +func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesRequest), arg0) +} + +// UnassignPrivateIpAddressesWithContext mocks base method +func (m *MockEC2API) UnassignPrivateIpAddressesWithContext(arg0 context.Context, arg1 *ec2.UnassignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.UnassignPrivateIpAddressesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnassignPrivateIpAddressesWithContext indicates an expected call of UnassignPrivateIpAddressesWithContext +func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesWithContext), varargs...) +} + +// UnmonitorInstances mocks base method +func (m *MockEC2API) UnmonitorInstances(arg0 *ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnmonitorInstances", arg0) + ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnmonitorInstances indicates an expected call of UnmonitorInstances +func (mr *MockEC2APIMockRecorder) UnmonitorInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstances", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstances), arg0) +} + +// UnmonitorInstancesRequest mocks base method +func (m *MockEC2API) UnmonitorInstancesRequest(arg0 *ec2.UnmonitorInstancesInput) (*request.Request, *ec2.UnmonitorInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnmonitorInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.UnmonitorInstancesOutput) + return ret0, ret1 +} + +// UnmonitorInstancesRequest indicates an expected call of UnmonitorInstancesRequest +func (mr *MockEC2APIMockRecorder) UnmonitorInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstancesRequest), arg0) +} + +// UnmonitorInstancesWithContext mocks base method +func (m *MockEC2API) UnmonitorInstancesWithContext(arg0 context.Context, arg1 *ec2.UnmonitorInstancesInput, arg2 ...request.Option) (*ec2.UnmonitorInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnmonitorInstancesWithContext", varargs...) + ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnmonitorInstancesWithContext indicates an expected call of UnmonitorInstancesWithContext +func (mr *MockEC2APIMockRecorder) UnmonitorInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstancesWithContext), varargs...) +} + +// UpdateSecurityGroupRuleDescriptionsEgress mocks base method +func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgress", arg0) + ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSecurityGroupRuleDescriptionsEgress indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgress +func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgress), arg0) +} + +// UpdateSecurityGroupRuleDescriptionsEgressRequest mocks base method +func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) + return ret0, ret1 +} + +// UpdateSecurityGroupRuleDescriptionsEgressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressRequest +func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressRequest), arg0) +} + +// UpdateSecurityGroupRuleDescriptionsEgressWithContext mocks base method +func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressWithContext(arg0 context.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSecurityGroupRuleDescriptionsEgressWithContext indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressWithContext +func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressWithContext), varargs...) +} + +// UpdateSecurityGroupRuleDescriptionsIngress mocks base method +func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngress", arg0) + ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSecurityGroupRuleDescriptionsIngress indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngress +func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngress(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngress), arg0) +} + +// UpdateSecurityGroupRuleDescriptionsIngressRequest mocks base method +func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) + return ret0, ret1 +} + +// UpdateSecurityGroupRuleDescriptionsIngressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressRequest +func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressRequest), arg0) +} + +// UpdateSecurityGroupRuleDescriptionsIngressWithContext mocks base method +func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressWithContext(arg0 context.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", varargs...) + ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSecurityGroupRuleDescriptionsIngressWithContext indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressWithContext +func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressWithContext), varargs...) +} + +// WaitUntilBundleTaskComplete mocks base method +func (m *MockEC2API) WaitUntilBundleTaskComplete(arg0 *ec2.DescribeBundleTasksInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilBundleTaskComplete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilBundleTaskComplete indicates an expected call of WaitUntilBundleTaskComplete +func (mr *MockEC2APIMockRecorder) WaitUntilBundleTaskComplete(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBundleTaskComplete", reflect.TypeOf((*MockEC2API)(nil).WaitUntilBundleTaskComplete), arg0) +} + +// WaitUntilBundleTaskCompleteWithContext mocks base method +func (m *MockEC2API) WaitUntilBundleTaskCompleteWithContext(arg0 context.Context, arg1 *ec2.DescribeBundleTasksInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilBundleTaskCompleteWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilBundleTaskCompleteWithContext indicates an expected call of WaitUntilBundleTaskCompleteWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilBundleTaskCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBundleTaskCompleteWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilBundleTaskCompleteWithContext), varargs...) +} + +// WaitUntilConversionTaskCancelled mocks base method +func (m *MockEC2API) WaitUntilConversionTaskCancelled(arg0 *ec2.DescribeConversionTasksInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilConversionTaskCancelled", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilConversionTaskCancelled indicates an expected call of WaitUntilConversionTaskCancelled +func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCancelled(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCancelled), arg0) +} + +// WaitUntilConversionTaskCancelledWithContext mocks base method +func (m *MockEC2API) WaitUntilConversionTaskCancelledWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilConversionTaskCancelledWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilConversionTaskCancelledWithContext indicates an expected call of WaitUntilConversionTaskCancelledWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCancelledWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCancelledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCancelledWithContext), varargs...) +} + +// WaitUntilConversionTaskCompleted mocks base method +func (m *MockEC2API) WaitUntilConversionTaskCompleted(arg0 *ec2.DescribeConversionTasksInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilConversionTaskCompleted", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilConversionTaskCompleted indicates an expected call of WaitUntilConversionTaskCompleted +func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCompleted(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCompleted), arg0) +} + +// WaitUntilConversionTaskCompletedWithContext mocks base method +func (m *MockEC2API) WaitUntilConversionTaskCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilConversionTaskCompletedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilConversionTaskCompletedWithContext indicates an expected call of WaitUntilConversionTaskCompletedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCompletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCompletedWithContext), varargs...) +} + +// WaitUntilConversionTaskDeleted mocks base method +func (m *MockEC2API) WaitUntilConversionTaskDeleted(arg0 *ec2.DescribeConversionTasksInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilConversionTaskDeleted", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilConversionTaskDeleted indicates an expected call of WaitUntilConversionTaskDeleted +func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskDeleted(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskDeleted), arg0) +} + +// WaitUntilConversionTaskDeletedWithContext mocks base method +func (m *MockEC2API) WaitUntilConversionTaskDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilConversionTaskDeletedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilConversionTaskDeletedWithContext indicates an expected call of WaitUntilConversionTaskDeletedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskDeletedWithContext), varargs...) +} + +// WaitUntilCustomerGatewayAvailable mocks base method +func (m *MockEC2API) WaitUntilCustomerGatewayAvailable(arg0 *ec2.DescribeCustomerGatewaysInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilCustomerGatewayAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilCustomerGatewayAvailable indicates an expected call of WaitUntilCustomerGatewayAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilCustomerGatewayAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCustomerGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailable), arg0) +} + +// WaitUntilCustomerGatewayAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilCustomerGatewayAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilCustomerGatewayAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilCustomerGatewayAvailableWithContext indicates an expected call of WaitUntilCustomerGatewayAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilCustomerGatewayAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCustomerGatewayAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailableWithContext), varargs...) +} + +// WaitUntilExportTaskCancelled mocks base method +func (m *MockEC2API) WaitUntilExportTaskCancelled(arg0 *ec2.DescribeExportTasksInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilExportTaskCancelled", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilExportTaskCancelled indicates an expected call of WaitUntilExportTaskCancelled +func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCancelled(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCancelled), arg0) +} + +// WaitUntilExportTaskCancelledWithContext mocks base method +func (m *MockEC2API) WaitUntilExportTaskCancelledWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilExportTaskCancelledWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilExportTaskCancelledWithContext indicates an expected call of WaitUntilExportTaskCancelledWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCancelledWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCancelledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCancelledWithContext), varargs...) +} + +// WaitUntilExportTaskCompleted mocks base method +func (m *MockEC2API) WaitUntilExportTaskCompleted(arg0 *ec2.DescribeExportTasksInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilExportTaskCompleted", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilExportTaskCompleted indicates an expected call of WaitUntilExportTaskCompleted +func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCompleted(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCompleted), arg0) +} + +// WaitUntilExportTaskCompletedWithContext mocks base method +func (m *MockEC2API) WaitUntilExportTaskCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilExportTaskCompletedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilExportTaskCompletedWithContext indicates an expected call of WaitUntilExportTaskCompletedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCompletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCompletedWithContext), varargs...) +} + +// WaitUntilImageAvailable mocks base method +func (m *MockEC2API) WaitUntilImageAvailable(arg0 *ec2.DescribeImagesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilImageAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilImageAvailable indicates an expected call of WaitUntilImageAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilImageAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageAvailable), arg0) +} + +// WaitUntilImageAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilImageAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilImageAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilImageAvailableWithContext indicates an expected call of WaitUntilImageAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilImageAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageAvailableWithContext), varargs...) +} + +// WaitUntilImageExists mocks base method +func (m *MockEC2API) WaitUntilImageExists(arg0 *ec2.DescribeImagesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilImageExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilImageExists indicates an expected call of WaitUntilImageExists +func (mr *MockEC2APIMockRecorder) WaitUntilImageExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageExists), arg0) +} + +// WaitUntilImageExistsWithContext mocks base method +func (m *MockEC2API) WaitUntilImageExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilImageExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilImageExistsWithContext indicates an expected call of WaitUntilImageExistsWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilImageExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageExistsWithContext), varargs...) +} + +// WaitUntilInstanceExists mocks base method +func (m *MockEC2API) WaitUntilInstanceExists(arg0 *ec2.DescribeInstancesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilInstanceExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceExists indicates an expected call of WaitUntilInstanceExists +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceExists), arg0) +} + +// WaitUntilInstanceExistsWithContext mocks base method +func (m *MockEC2API) WaitUntilInstanceExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilInstanceExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceExistsWithContext indicates an expected call of WaitUntilInstanceExistsWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceExistsWithContext), varargs...) +} + +// WaitUntilInstanceRunning mocks base method +func (m *MockEC2API) WaitUntilInstanceRunning(arg0 *ec2.DescribeInstancesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilInstanceRunning", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceRunning indicates an expected call of WaitUntilInstanceRunning +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceRunning(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceRunning", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceRunning), arg0) +} + +// WaitUntilInstanceRunningWithContext mocks base method +func (m *MockEC2API) WaitUntilInstanceRunningWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilInstanceRunningWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceRunningWithContext indicates an expected call of WaitUntilInstanceRunningWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceRunningWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceRunningWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceRunningWithContext), varargs...) +} + +// WaitUntilInstanceStatusOk mocks base method +func (m *MockEC2API) WaitUntilInstanceStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilInstanceStatusOk", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceStatusOk indicates an expected call of WaitUntilInstanceStatusOk +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStatusOk(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStatusOk), arg0) +} + +// WaitUntilInstanceStatusOkWithContext mocks base method +func (m *MockEC2API) WaitUntilInstanceStatusOkWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilInstanceStatusOkWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceStatusOkWithContext indicates an expected call of WaitUntilInstanceStatusOkWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStatusOkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStatusOkWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStatusOkWithContext), varargs...) +} + +// WaitUntilInstanceStopped mocks base method +func (m *MockEC2API) WaitUntilInstanceStopped(arg0 *ec2.DescribeInstancesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilInstanceStopped", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceStopped indicates an expected call of WaitUntilInstanceStopped +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStopped(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStopped", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStopped), arg0) +} + +// WaitUntilInstanceStoppedWithContext mocks base method +func (m *MockEC2API) WaitUntilInstanceStoppedWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilInstanceStoppedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceStoppedWithContext indicates an expected call of WaitUntilInstanceStoppedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStoppedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStoppedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStoppedWithContext), varargs...) +} + +// WaitUntilInstanceTerminated mocks base method +func (m *MockEC2API) WaitUntilInstanceTerminated(arg0 *ec2.DescribeInstancesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilInstanceTerminated", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceTerminated indicates an expected call of WaitUntilInstanceTerminated +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceTerminated(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceTerminated", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceTerminated), arg0) +} + +// WaitUntilInstanceTerminatedWithContext mocks base method +func (m *MockEC2API) WaitUntilInstanceTerminatedWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilInstanceTerminatedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceTerminatedWithContext indicates an expected call of WaitUntilInstanceTerminatedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilInstanceTerminatedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceTerminatedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceTerminatedWithContext), varargs...) +} + +// WaitUntilKeyPairExists mocks base method +func (m *MockEC2API) WaitUntilKeyPairExists(arg0 *ec2.DescribeKeyPairsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilKeyPairExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilKeyPairExists indicates an expected call of WaitUntilKeyPairExists +func (mr *MockEC2APIMockRecorder) WaitUntilKeyPairExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilKeyPairExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilKeyPairExists), arg0) +} + +// WaitUntilKeyPairExistsWithContext mocks base method +func (m *MockEC2API) WaitUntilKeyPairExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeKeyPairsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilKeyPairExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilKeyPairExistsWithContext indicates an expected call of WaitUntilKeyPairExistsWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilKeyPairExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilKeyPairExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilKeyPairExistsWithContext), varargs...) +} + +// WaitUntilNatGatewayAvailable mocks base method +func (m *MockEC2API) WaitUntilNatGatewayAvailable(arg0 *ec2.DescribeNatGatewaysInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilNatGatewayAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilNatGatewayAvailable indicates an expected call of WaitUntilNatGatewayAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayAvailable), arg0) +} + +// WaitUntilNatGatewayAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilNatGatewayAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilNatGatewayAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilNatGatewayAvailableWithContext indicates an expected call of WaitUntilNatGatewayAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayAvailableWithContext), varargs...) +} + +// WaitUntilNetworkInterfaceAvailable mocks base method +func (m *MockEC2API) WaitUntilNetworkInterfaceAvailable(arg0 *ec2.DescribeNetworkInterfacesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilNetworkInterfaceAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilNetworkInterfaceAvailable indicates an expected call of WaitUntilNetworkInterfaceAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilNetworkInterfaceAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNetworkInterfaceAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailable), arg0) +} + +// WaitUntilNetworkInterfaceAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilNetworkInterfaceAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilNetworkInterfaceAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilNetworkInterfaceAvailableWithContext indicates an expected call of WaitUntilNetworkInterfaceAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilNetworkInterfaceAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNetworkInterfaceAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailableWithContext), varargs...) +} + +// WaitUntilPasswordDataAvailable mocks base method +func (m *MockEC2API) WaitUntilPasswordDataAvailable(arg0 *ec2.GetPasswordDataInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilPasswordDataAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilPasswordDataAvailable indicates an expected call of WaitUntilPasswordDataAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilPasswordDataAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPasswordDataAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilPasswordDataAvailable), arg0) +} + +// WaitUntilPasswordDataAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilPasswordDataAvailableWithContext(arg0 context.Context, arg1 *ec2.GetPasswordDataInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilPasswordDataAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilPasswordDataAvailableWithContext indicates an expected call of WaitUntilPasswordDataAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilPasswordDataAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPasswordDataAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilPasswordDataAvailableWithContext), varargs...) +} + +// WaitUntilSecurityGroupExists mocks base method +func (m *MockEC2API) WaitUntilSecurityGroupExists(arg0 *ec2.DescribeSecurityGroupsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilSecurityGroupExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSecurityGroupExists indicates an expected call of WaitUntilSecurityGroupExists +func (mr *MockEC2APIMockRecorder) WaitUntilSecurityGroupExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSecurityGroupExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSecurityGroupExists), arg0) +} + +// WaitUntilSecurityGroupExistsWithContext mocks base method +func (m *MockEC2API) WaitUntilSecurityGroupExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilSecurityGroupExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSecurityGroupExistsWithContext indicates an expected call of WaitUntilSecurityGroupExistsWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilSecurityGroupExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSecurityGroupExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSecurityGroupExistsWithContext), varargs...) +} + +// WaitUntilSnapshotCompleted mocks base method +func (m *MockEC2API) WaitUntilSnapshotCompleted(arg0 *ec2.DescribeSnapshotsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilSnapshotCompleted", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSnapshotCompleted indicates an expected call of WaitUntilSnapshotCompleted +func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotCompleted(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompleted), arg0) +} + +// WaitUntilSnapshotCompletedWithContext mocks base method +func (m *MockEC2API) WaitUntilSnapshotCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilSnapshotCompletedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSnapshotCompletedWithContext indicates an expected call of WaitUntilSnapshotCompletedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotCompletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompletedWithContext), varargs...) +} + +// WaitUntilSpotInstanceRequestFulfilled mocks base method +func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilled(arg0 *ec2.DescribeSpotInstanceRequestsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilSpotInstanceRequestFulfilled", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSpotInstanceRequestFulfilled indicates an expected call of WaitUntilSpotInstanceRequestFulfilled +func (mr *MockEC2APIMockRecorder) WaitUntilSpotInstanceRequestFulfilled(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSpotInstanceRequestFulfilled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilled), arg0) +} + +// WaitUntilSpotInstanceRequestFulfilledWithContext mocks base method +func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilledWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilSpotInstanceRequestFulfilledWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSpotInstanceRequestFulfilledWithContext indicates an expected call of WaitUntilSpotInstanceRequestFulfilledWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilSpotInstanceRequestFulfilledWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSpotInstanceRequestFulfilledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilledWithContext), varargs...) +} + +// WaitUntilSubnetAvailable mocks base method +func (m *MockEC2API) WaitUntilSubnetAvailable(arg0 *ec2.DescribeSubnetsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilSubnetAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSubnetAvailable indicates an expected call of WaitUntilSubnetAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilSubnetAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSubnetAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSubnetAvailable), arg0) +} + +// WaitUntilSubnetAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilSubnetAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilSubnetAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSubnetAvailableWithContext indicates an expected call of WaitUntilSubnetAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilSubnetAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSubnetAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSubnetAvailableWithContext), varargs...) +} + +// WaitUntilSystemStatusOk mocks base method +func (m *MockEC2API) WaitUntilSystemStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilSystemStatusOk", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSystemStatusOk indicates an expected call of WaitUntilSystemStatusOk +func (mr *MockEC2APIMockRecorder) WaitUntilSystemStatusOk(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSystemStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSystemStatusOk), arg0) +} + +// WaitUntilSystemStatusOkWithContext mocks base method +func (m *MockEC2API) WaitUntilSystemStatusOkWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilSystemStatusOkWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilSystemStatusOkWithContext indicates an expected call of WaitUntilSystemStatusOkWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilSystemStatusOkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSystemStatusOkWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSystemStatusOkWithContext), varargs...) +} + +// WaitUntilVolumeAvailable mocks base method +func (m *MockEC2API) WaitUntilVolumeAvailable(arg0 *ec2.DescribeVolumesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVolumeAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVolumeAvailable indicates an expected call of WaitUntilVolumeAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilVolumeAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeAvailable), arg0) +} + +// WaitUntilVolumeAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilVolumeAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVolumeAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVolumeAvailableWithContext indicates an expected call of WaitUntilVolumeAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVolumeAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeAvailableWithContext), varargs...) +} + +// WaitUntilVolumeDeleted mocks base method +func (m *MockEC2API) WaitUntilVolumeDeleted(arg0 *ec2.DescribeVolumesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVolumeDeleted", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVolumeDeleted indicates an expected call of WaitUntilVolumeDeleted +func (mr *MockEC2APIMockRecorder) WaitUntilVolumeDeleted(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeDeleted), arg0) +} + +// WaitUntilVolumeDeletedWithContext mocks base method +func (m *MockEC2API) WaitUntilVolumeDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVolumeDeletedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVolumeDeletedWithContext indicates an expected call of WaitUntilVolumeDeletedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVolumeDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeDeletedWithContext), varargs...) +} + +// WaitUntilVolumeInUse mocks base method +func (m *MockEC2API) WaitUntilVolumeInUse(arg0 *ec2.DescribeVolumesInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVolumeInUse", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVolumeInUse indicates an expected call of WaitUntilVolumeInUse +func (mr *MockEC2APIMockRecorder) WaitUntilVolumeInUse(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeInUse", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeInUse), arg0) +} + +// WaitUntilVolumeInUseWithContext mocks base method +func (m *MockEC2API) WaitUntilVolumeInUseWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVolumeInUseWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVolumeInUseWithContext indicates an expected call of WaitUntilVolumeInUseWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVolumeInUseWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeInUseWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeInUseWithContext), varargs...) +} + +// WaitUntilVpcAvailable mocks base method +func (m *MockEC2API) WaitUntilVpcAvailable(arg0 *ec2.DescribeVpcsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVpcAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpcAvailable indicates an expected call of WaitUntilVpcAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilVpcAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcAvailable), arg0) +} + +// WaitUntilVpcAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilVpcAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVpcAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpcAvailableWithContext indicates an expected call of WaitUntilVpcAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVpcAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcAvailableWithContext), varargs...) +} + +// WaitUntilVpcExists mocks base method +func (m *MockEC2API) WaitUntilVpcExists(arg0 *ec2.DescribeVpcsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVpcExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpcExists indicates an expected call of WaitUntilVpcExists +func (mr *MockEC2APIMockRecorder) WaitUntilVpcExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcExists), arg0) +} + +// WaitUntilVpcExistsWithContext mocks base method +func (m *MockEC2API) WaitUntilVpcExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVpcExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpcExistsWithContext indicates an expected call of WaitUntilVpcExistsWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVpcExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcExistsWithContext), varargs...) +} + +// WaitUntilVpcPeeringConnectionDeleted mocks base method +func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeleted(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionDeleted", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpcPeeringConnectionDeleted indicates an expected call of WaitUntilVpcPeeringConnectionDeleted +func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionDeleted(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeleted), arg0) +} + +// WaitUntilVpcPeeringConnectionDeletedWithContext mocks base method +func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionDeletedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpcPeeringConnectionDeletedWithContext indicates an expected call of WaitUntilVpcPeeringConnectionDeletedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeletedWithContext), varargs...) +} + +// WaitUntilVpcPeeringConnectionExists mocks base method +func (m *MockEC2API) WaitUntilVpcPeeringConnectionExists(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpcPeeringConnectionExists indicates an expected call of WaitUntilVpcPeeringConnectionExists +func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExists), arg0) +} + +// WaitUntilVpcPeeringConnectionExistsWithContext mocks base method +func (m *MockEC2API) WaitUntilVpcPeeringConnectionExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpcPeeringConnectionExistsWithContext indicates an expected call of WaitUntilVpcPeeringConnectionExistsWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExistsWithContext), varargs...) +} + +// WaitUntilVpnConnectionAvailable mocks base method +func (m *MockEC2API) WaitUntilVpnConnectionAvailable(arg0 *ec2.DescribeVpnConnectionsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVpnConnectionAvailable", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpnConnectionAvailable indicates an expected call of WaitUntilVpnConnectionAvailable +func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailable(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailable), arg0) +} + +// WaitUntilVpnConnectionAvailableWithContext mocks base method +func (m *MockEC2API) WaitUntilVpnConnectionAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVpnConnectionAvailableWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpnConnectionAvailableWithContext indicates an expected call of WaitUntilVpnConnectionAvailableWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailableWithContext), varargs...) +} + +// WaitUntilVpnConnectionDeleted mocks base method +func (m *MockEC2API) WaitUntilVpnConnectionDeleted(arg0 *ec2.DescribeVpnConnectionsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilVpnConnectionDeleted", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpnConnectionDeleted indicates an expected call of WaitUntilVpnConnectionDeleted +func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeleted(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeleted), arg0) +} + +// WaitUntilVpnConnectionDeletedWithContext mocks base method +func (m *MockEC2API) WaitUntilVpnConnectionDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilVpnConnectionDeletedWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilVpnConnectionDeletedWithContext indicates an expected call of WaitUntilVpnConnectionDeletedWithContext +func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeletedWithContext), varargs...) +} + +// WithdrawByoipCidr mocks base method +func (m *MockEC2API) WithdrawByoipCidr(arg0 *ec2.WithdrawByoipCidrInput) (*ec2.WithdrawByoipCidrOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WithdrawByoipCidr", arg0) + ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// WithdrawByoipCidr indicates an expected call of WithdrawByoipCidr +func (mr *MockEC2APIMockRecorder) WithdrawByoipCidr(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidr", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidr), arg0) +} + +// WithdrawByoipCidrRequest mocks base method +func (m *MockEC2API) WithdrawByoipCidrRequest(arg0 *ec2.WithdrawByoipCidrInput) (*request.Request, *ec2.WithdrawByoipCidrOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WithdrawByoipCidrRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ec2.WithdrawByoipCidrOutput) + return ret0, ret1 +} + +// WithdrawByoipCidrRequest indicates an expected call of WithdrawByoipCidrRequest +func (mr *MockEC2APIMockRecorder) WithdrawByoipCidrRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrRequest), arg0) +} + +// WithdrawByoipCidrWithContext mocks base method +func (m *MockEC2API) WithdrawByoipCidrWithContext(arg0 context.Context, arg1 *ec2.WithdrawByoipCidrInput, arg2 ...request.Option) (*ec2.WithdrawByoipCidrOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WithdrawByoipCidrWithContext", varargs...) + ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// WithdrawByoipCidrWithContext indicates an expected call of WithdrawByoipCidrWithContext +func (mr *MockEC2APIMockRecorder) WithdrawByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrWithContext), varargs...) +} diff --git a/pkg/mocks/mock_ecr.go b/pkg/mocks/mock_ecr.go new file mode 100644 index 0000000..906d676 --- /dev/null +++ b/pkg/mocks/mock_ecr.go @@ -0,0 +1,1717 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/ecr/ecriface (interfaces: ECRAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + ecr "github.com/aws/aws-sdk-go/service/ecr" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockECRAPI is a mock of ECRAPI interface +type MockECRAPI struct { + ctrl *gomock.Controller + recorder *MockECRAPIMockRecorder +} + +// MockECRAPIMockRecorder is the mock recorder for MockECRAPI +type MockECRAPIMockRecorder struct { + mock *MockECRAPI +} + +// NewMockECRAPI creates a new mock instance +func NewMockECRAPI(ctrl *gomock.Controller) *MockECRAPI { + mock := &MockECRAPI{ctrl: ctrl} + mock.recorder = &MockECRAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockECRAPI) EXPECT() *MockECRAPIMockRecorder { + return m.recorder +} + +// BatchCheckLayerAvailability mocks base method +func (m *MockECRAPI) BatchCheckLayerAvailability(arg0 *ecr.BatchCheckLayerAvailabilityInput) (*ecr.BatchCheckLayerAvailabilityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchCheckLayerAvailability", arg0) + ret0, _ := ret[0].(*ecr.BatchCheckLayerAvailabilityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchCheckLayerAvailability indicates an expected call of BatchCheckLayerAvailability +func (mr *MockECRAPIMockRecorder) BatchCheckLayerAvailability(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCheckLayerAvailability", reflect.TypeOf((*MockECRAPI)(nil).BatchCheckLayerAvailability), arg0) +} + +// BatchCheckLayerAvailabilityRequest mocks base method +func (m *MockECRAPI) BatchCheckLayerAvailabilityRequest(arg0 *ecr.BatchCheckLayerAvailabilityInput) (*request.Request, *ecr.BatchCheckLayerAvailabilityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchCheckLayerAvailabilityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.BatchCheckLayerAvailabilityOutput) + return ret0, ret1 +} + +// BatchCheckLayerAvailabilityRequest indicates an expected call of BatchCheckLayerAvailabilityRequest +func (mr *MockECRAPIMockRecorder) BatchCheckLayerAvailabilityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCheckLayerAvailabilityRequest", reflect.TypeOf((*MockECRAPI)(nil).BatchCheckLayerAvailabilityRequest), arg0) +} + +// BatchCheckLayerAvailabilityWithContext mocks base method +func (m *MockECRAPI) BatchCheckLayerAvailabilityWithContext(arg0 context.Context, arg1 *ecr.BatchCheckLayerAvailabilityInput, arg2 ...request.Option) (*ecr.BatchCheckLayerAvailabilityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchCheckLayerAvailabilityWithContext", varargs...) + ret0, _ := ret[0].(*ecr.BatchCheckLayerAvailabilityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchCheckLayerAvailabilityWithContext indicates an expected call of BatchCheckLayerAvailabilityWithContext +func (mr *MockECRAPIMockRecorder) BatchCheckLayerAvailabilityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCheckLayerAvailabilityWithContext", reflect.TypeOf((*MockECRAPI)(nil).BatchCheckLayerAvailabilityWithContext), varargs...) +} + +// BatchDeleteImage mocks base method +func (m *MockECRAPI) BatchDeleteImage(arg0 *ecr.BatchDeleteImageInput) (*ecr.BatchDeleteImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchDeleteImage", arg0) + ret0, _ := ret[0].(*ecr.BatchDeleteImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchDeleteImage indicates an expected call of BatchDeleteImage +func (mr *MockECRAPIMockRecorder) BatchDeleteImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteImage", reflect.TypeOf((*MockECRAPI)(nil).BatchDeleteImage), arg0) +} + +// BatchDeleteImageRequest mocks base method +func (m *MockECRAPI) BatchDeleteImageRequest(arg0 *ecr.BatchDeleteImageInput) (*request.Request, *ecr.BatchDeleteImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchDeleteImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.BatchDeleteImageOutput) + return ret0, ret1 +} + +// BatchDeleteImageRequest indicates an expected call of BatchDeleteImageRequest +func (mr *MockECRAPIMockRecorder) BatchDeleteImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteImageRequest", reflect.TypeOf((*MockECRAPI)(nil).BatchDeleteImageRequest), arg0) +} + +// BatchDeleteImageWithContext mocks base method +func (m *MockECRAPI) BatchDeleteImageWithContext(arg0 context.Context, arg1 *ecr.BatchDeleteImageInput, arg2 ...request.Option) (*ecr.BatchDeleteImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchDeleteImageWithContext", varargs...) + ret0, _ := ret[0].(*ecr.BatchDeleteImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchDeleteImageWithContext indicates an expected call of BatchDeleteImageWithContext +func (mr *MockECRAPIMockRecorder) BatchDeleteImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteImageWithContext", reflect.TypeOf((*MockECRAPI)(nil).BatchDeleteImageWithContext), varargs...) +} + +// BatchGetImage mocks base method +func (m *MockECRAPI) BatchGetImage(arg0 *ecr.BatchGetImageInput) (*ecr.BatchGetImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetImage", arg0) + ret0, _ := ret[0].(*ecr.BatchGetImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetImage indicates an expected call of BatchGetImage +func (mr *MockECRAPIMockRecorder) BatchGetImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetImage", reflect.TypeOf((*MockECRAPI)(nil).BatchGetImage), arg0) +} + +// BatchGetImageRequest mocks base method +func (m *MockECRAPI) BatchGetImageRequest(arg0 *ecr.BatchGetImageInput) (*request.Request, *ecr.BatchGetImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.BatchGetImageOutput) + return ret0, ret1 +} + +// BatchGetImageRequest indicates an expected call of BatchGetImageRequest +func (mr *MockECRAPIMockRecorder) BatchGetImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetImageRequest", reflect.TypeOf((*MockECRAPI)(nil).BatchGetImageRequest), arg0) +} + +// BatchGetImageWithContext mocks base method +func (m *MockECRAPI) BatchGetImageWithContext(arg0 context.Context, arg1 *ecr.BatchGetImageInput, arg2 ...request.Option) (*ecr.BatchGetImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchGetImageWithContext", varargs...) + ret0, _ := ret[0].(*ecr.BatchGetImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetImageWithContext indicates an expected call of BatchGetImageWithContext +func (mr *MockECRAPIMockRecorder) BatchGetImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetImageWithContext", reflect.TypeOf((*MockECRAPI)(nil).BatchGetImageWithContext), varargs...) +} + +// CompleteLayerUpload mocks base method +func (m *MockECRAPI) CompleteLayerUpload(arg0 *ecr.CompleteLayerUploadInput) (*ecr.CompleteLayerUploadOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteLayerUpload", arg0) + ret0, _ := ret[0].(*ecr.CompleteLayerUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteLayerUpload indicates an expected call of CompleteLayerUpload +func (mr *MockECRAPIMockRecorder) CompleteLayerUpload(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLayerUpload", reflect.TypeOf((*MockECRAPI)(nil).CompleteLayerUpload), arg0) +} + +// CompleteLayerUploadRequest mocks base method +func (m *MockECRAPI) CompleteLayerUploadRequest(arg0 *ecr.CompleteLayerUploadInput) (*request.Request, *ecr.CompleteLayerUploadOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteLayerUploadRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.CompleteLayerUploadOutput) + return ret0, ret1 +} + +// CompleteLayerUploadRequest indicates an expected call of CompleteLayerUploadRequest +func (mr *MockECRAPIMockRecorder) CompleteLayerUploadRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLayerUploadRequest", reflect.TypeOf((*MockECRAPI)(nil).CompleteLayerUploadRequest), arg0) +} + +// CompleteLayerUploadWithContext mocks base method +func (m *MockECRAPI) CompleteLayerUploadWithContext(arg0 context.Context, arg1 *ecr.CompleteLayerUploadInput, arg2 ...request.Option) (*ecr.CompleteLayerUploadOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CompleteLayerUploadWithContext", varargs...) + ret0, _ := ret[0].(*ecr.CompleteLayerUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteLayerUploadWithContext indicates an expected call of CompleteLayerUploadWithContext +func (mr *MockECRAPIMockRecorder) CompleteLayerUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLayerUploadWithContext", reflect.TypeOf((*MockECRAPI)(nil).CompleteLayerUploadWithContext), varargs...) +} + +// CreateRepository mocks base method +func (m *MockECRAPI) CreateRepository(arg0 *ecr.CreateRepositoryInput) (*ecr.CreateRepositoryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRepository", arg0) + ret0, _ := ret[0].(*ecr.CreateRepositoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRepository indicates an expected call of CreateRepository +func (mr *MockECRAPIMockRecorder) CreateRepository(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepository", reflect.TypeOf((*MockECRAPI)(nil).CreateRepository), arg0) +} + +// CreateRepositoryRequest mocks base method +func (m *MockECRAPI) CreateRepositoryRequest(arg0 *ecr.CreateRepositoryInput) (*request.Request, *ecr.CreateRepositoryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRepositoryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.CreateRepositoryOutput) + return ret0, ret1 +} + +// CreateRepositoryRequest indicates an expected call of CreateRepositoryRequest +func (mr *MockECRAPIMockRecorder) CreateRepositoryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepositoryRequest", reflect.TypeOf((*MockECRAPI)(nil).CreateRepositoryRequest), arg0) +} + +// CreateRepositoryWithContext mocks base method +func (m *MockECRAPI) CreateRepositoryWithContext(arg0 context.Context, arg1 *ecr.CreateRepositoryInput, arg2 ...request.Option) (*ecr.CreateRepositoryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRepositoryWithContext", varargs...) + ret0, _ := ret[0].(*ecr.CreateRepositoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRepositoryWithContext indicates an expected call of CreateRepositoryWithContext +func (mr *MockECRAPIMockRecorder) CreateRepositoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepositoryWithContext", reflect.TypeOf((*MockECRAPI)(nil).CreateRepositoryWithContext), varargs...) +} + +// DeleteLifecyclePolicy mocks base method +func (m *MockECRAPI) DeleteLifecyclePolicy(arg0 *ecr.DeleteLifecyclePolicyInput) (*ecr.DeleteLifecyclePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLifecyclePolicy", arg0) + ret0, _ := ret[0].(*ecr.DeleteLifecyclePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLifecyclePolicy indicates an expected call of DeleteLifecyclePolicy +func (mr *MockECRAPIMockRecorder) DeleteLifecyclePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecyclePolicy", reflect.TypeOf((*MockECRAPI)(nil).DeleteLifecyclePolicy), arg0) +} + +// DeleteLifecyclePolicyRequest mocks base method +func (m *MockECRAPI) DeleteLifecyclePolicyRequest(arg0 *ecr.DeleteLifecyclePolicyInput) (*request.Request, *ecr.DeleteLifecyclePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLifecyclePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.DeleteLifecyclePolicyOutput) + return ret0, ret1 +} + +// DeleteLifecyclePolicyRequest indicates an expected call of DeleteLifecyclePolicyRequest +func (mr *MockECRAPIMockRecorder) DeleteLifecyclePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecyclePolicyRequest", reflect.TypeOf((*MockECRAPI)(nil).DeleteLifecyclePolicyRequest), arg0) +} + +// DeleteLifecyclePolicyWithContext mocks base method +func (m *MockECRAPI) DeleteLifecyclePolicyWithContext(arg0 context.Context, arg1 *ecr.DeleteLifecyclePolicyInput, arg2 ...request.Option) (*ecr.DeleteLifecyclePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLifecyclePolicyWithContext", varargs...) + ret0, _ := ret[0].(*ecr.DeleteLifecyclePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLifecyclePolicyWithContext indicates an expected call of DeleteLifecyclePolicyWithContext +func (mr *MockECRAPIMockRecorder) DeleteLifecyclePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecyclePolicyWithContext", reflect.TypeOf((*MockECRAPI)(nil).DeleteLifecyclePolicyWithContext), varargs...) +} + +// DeleteRepository mocks base method +func (m *MockECRAPI) DeleteRepository(arg0 *ecr.DeleteRepositoryInput) (*ecr.DeleteRepositoryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRepository", arg0) + ret0, _ := ret[0].(*ecr.DeleteRepositoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRepository indicates an expected call of DeleteRepository +func (mr *MockECRAPIMockRecorder) DeleteRepository(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepository", reflect.TypeOf((*MockECRAPI)(nil).DeleteRepository), arg0) +} + +// DeleteRepositoryPolicy mocks base method +func (m *MockECRAPI) DeleteRepositoryPolicy(arg0 *ecr.DeleteRepositoryPolicyInput) (*ecr.DeleteRepositoryPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRepositoryPolicy", arg0) + ret0, _ := ret[0].(*ecr.DeleteRepositoryPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRepositoryPolicy indicates an expected call of DeleteRepositoryPolicy +func (mr *MockECRAPIMockRecorder) DeleteRepositoryPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepositoryPolicy", reflect.TypeOf((*MockECRAPI)(nil).DeleteRepositoryPolicy), arg0) +} + +// DeleteRepositoryPolicyRequest mocks base method +func (m *MockECRAPI) DeleteRepositoryPolicyRequest(arg0 *ecr.DeleteRepositoryPolicyInput) (*request.Request, *ecr.DeleteRepositoryPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRepositoryPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.DeleteRepositoryPolicyOutput) + return ret0, ret1 +} + +// DeleteRepositoryPolicyRequest indicates an expected call of DeleteRepositoryPolicyRequest +func (mr *MockECRAPIMockRecorder) DeleteRepositoryPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepositoryPolicyRequest", reflect.TypeOf((*MockECRAPI)(nil).DeleteRepositoryPolicyRequest), arg0) +} + +// DeleteRepositoryPolicyWithContext mocks base method +func (m *MockECRAPI) DeleteRepositoryPolicyWithContext(arg0 context.Context, arg1 *ecr.DeleteRepositoryPolicyInput, arg2 ...request.Option) (*ecr.DeleteRepositoryPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRepositoryPolicyWithContext", varargs...) + ret0, _ := ret[0].(*ecr.DeleteRepositoryPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRepositoryPolicyWithContext indicates an expected call of DeleteRepositoryPolicyWithContext +func (mr *MockECRAPIMockRecorder) DeleteRepositoryPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepositoryPolicyWithContext", reflect.TypeOf((*MockECRAPI)(nil).DeleteRepositoryPolicyWithContext), varargs...) +} + +// DeleteRepositoryRequest mocks base method +func (m *MockECRAPI) DeleteRepositoryRequest(arg0 *ecr.DeleteRepositoryInput) (*request.Request, *ecr.DeleteRepositoryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRepositoryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.DeleteRepositoryOutput) + return ret0, ret1 +} + +// DeleteRepositoryRequest indicates an expected call of DeleteRepositoryRequest +func (mr *MockECRAPIMockRecorder) DeleteRepositoryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepositoryRequest", reflect.TypeOf((*MockECRAPI)(nil).DeleteRepositoryRequest), arg0) +} + +// DeleteRepositoryWithContext mocks base method +func (m *MockECRAPI) DeleteRepositoryWithContext(arg0 context.Context, arg1 *ecr.DeleteRepositoryInput, arg2 ...request.Option) (*ecr.DeleteRepositoryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRepositoryWithContext", varargs...) + ret0, _ := ret[0].(*ecr.DeleteRepositoryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRepositoryWithContext indicates an expected call of DeleteRepositoryWithContext +func (mr *MockECRAPIMockRecorder) DeleteRepositoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRepositoryWithContext", reflect.TypeOf((*MockECRAPI)(nil).DeleteRepositoryWithContext), varargs...) +} + +// DescribeImageScanFindings mocks base method +func (m *MockECRAPI) DescribeImageScanFindings(arg0 *ecr.DescribeImageScanFindingsInput) (*ecr.DescribeImageScanFindingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImageScanFindings", arg0) + ret0, _ := ret[0].(*ecr.DescribeImageScanFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImageScanFindings indicates an expected call of DescribeImageScanFindings +func (mr *MockECRAPIMockRecorder) DescribeImageScanFindings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageScanFindings", reflect.TypeOf((*MockECRAPI)(nil).DescribeImageScanFindings), arg0) +} + +// DescribeImageScanFindingsPages mocks base method +func (m *MockECRAPI) DescribeImageScanFindingsPages(arg0 *ecr.DescribeImageScanFindingsInput, arg1 func(*ecr.DescribeImageScanFindingsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImageScanFindingsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeImageScanFindingsPages indicates an expected call of DescribeImageScanFindingsPages +func (mr *MockECRAPIMockRecorder) DescribeImageScanFindingsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageScanFindingsPages", reflect.TypeOf((*MockECRAPI)(nil).DescribeImageScanFindingsPages), arg0, arg1) +} + +// DescribeImageScanFindingsPagesWithContext mocks base method +func (m *MockECRAPI) DescribeImageScanFindingsPagesWithContext(arg0 context.Context, arg1 *ecr.DescribeImageScanFindingsInput, arg2 func(*ecr.DescribeImageScanFindingsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImageScanFindingsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeImageScanFindingsPagesWithContext indicates an expected call of DescribeImageScanFindingsPagesWithContext +func (mr *MockECRAPIMockRecorder) DescribeImageScanFindingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageScanFindingsPagesWithContext", reflect.TypeOf((*MockECRAPI)(nil).DescribeImageScanFindingsPagesWithContext), varargs...) +} + +// DescribeImageScanFindingsRequest mocks base method +func (m *MockECRAPI) DescribeImageScanFindingsRequest(arg0 *ecr.DescribeImageScanFindingsInput) (*request.Request, *ecr.DescribeImageScanFindingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImageScanFindingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.DescribeImageScanFindingsOutput) + return ret0, ret1 +} + +// DescribeImageScanFindingsRequest indicates an expected call of DescribeImageScanFindingsRequest +func (mr *MockECRAPIMockRecorder) DescribeImageScanFindingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageScanFindingsRequest", reflect.TypeOf((*MockECRAPI)(nil).DescribeImageScanFindingsRequest), arg0) +} + +// DescribeImageScanFindingsWithContext mocks base method +func (m *MockECRAPI) DescribeImageScanFindingsWithContext(arg0 context.Context, arg1 *ecr.DescribeImageScanFindingsInput, arg2 ...request.Option) (*ecr.DescribeImageScanFindingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImageScanFindingsWithContext", varargs...) + ret0, _ := ret[0].(*ecr.DescribeImageScanFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImageScanFindingsWithContext indicates an expected call of DescribeImageScanFindingsWithContext +func (mr *MockECRAPIMockRecorder) DescribeImageScanFindingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageScanFindingsWithContext", reflect.TypeOf((*MockECRAPI)(nil).DescribeImageScanFindingsWithContext), varargs...) +} + +// DescribeImages mocks base method +func (m *MockECRAPI) DescribeImages(arg0 *ecr.DescribeImagesInput) (*ecr.DescribeImagesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImages", arg0) + ret0, _ := ret[0].(*ecr.DescribeImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImages indicates an expected call of DescribeImages +func (mr *MockECRAPIMockRecorder) DescribeImages(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockECRAPI)(nil).DescribeImages), arg0) +} + +// DescribeImagesPages mocks base method +func (m *MockECRAPI) DescribeImagesPages(arg0 *ecr.DescribeImagesInput, arg1 func(*ecr.DescribeImagesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImagesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeImagesPages indicates an expected call of DescribeImagesPages +func (mr *MockECRAPIMockRecorder) DescribeImagesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesPages", reflect.TypeOf((*MockECRAPI)(nil).DescribeImagesPages), arg0, arg1) +} + +// DescribeImagesPagesWithContext mocks base method +func (m *MockECRAPI) DescribeImagesPagesWithContext(arg0 context.Context, arg1 *ecr.DescribeImagesInput, arg2 func(*ecr.DescribeImagesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImagesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeImagesPagesWithContext indicates an expected call of DescribeImagesPagesWithContext +func (mr *MockECRAPIMockRecorder) DescribeImagesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesPagesWithContext", reflect.TypeOf((*MockECRAPI)(nil).DescribeImagesPagesWithContext), varargs...) +} + +// DescribeImagesRequest mocks base method +func (m *MockECRAPI) DescribeImagesRequest(arg0 *ecr.DescribeImagesInput) (*request.Request, *ecr.DescribeImagesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeImagesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.DescribeImagesOutput) + return ret0, ret1 +} + +// DescribeImagesRequest indicates an expected call of DescribeImagesRequest +func (mr *MockECRAPIMockRecorder) DescribeImagesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesRequest", reflect.TypeOf((*MockECRAPI)(nil).DescribeImagesRequest), arg0) +} + +// DescribeImagesWithContext mocks base method +func (m *MockECRAPI) DescribeImagesWithContext(arg0 context.Context, arg1 *ecr.DescribeImagesInput, arg2 ...request.Option) (*ecr.DescribeImagesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeImagesWithContext", varargs...) + ret0, _ := ret[0].(*ecr.DescribeImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeImagesWithContext indicates an expected call of DescribeImagesWithContext +func (mr *MockECRAPIMockRecorder) DescribeImagesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesWithContext", reflect.TypeOf((*MockECRAPI)(nil).DescribeImagesWithContext), varargs...) +} + +// DescribeRepositories mocks base method +func (m *MockECRAPI) DescribeRepositories(arg0 *ecr.DescribeRepositoriesInput) (*ecr.DescribeRepositoriesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRepositories", arg0) + ret0, _ := ret[0].(*ecr.DescribeRepositoriesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRepositories indicates an expected call of DescribeRepositories +func (mr *MockECRAPIMockRecorder) DescribeRepositories(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRepositories", reflect.TypeOf((*MockECRAPI)(nil).DescribeRepositories), arg0) +} + +// DescribeRepositoriesPages mocks base method +func (m *MockECRAPI) DescribeRepositoriesPages(arg0 *ecr.DescribeRepositoriesInput, arg1 func(*ecr.DescribeRepositoriesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRepositoriesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRepositoriesPages indicates an expected call of DescribeRepositoriesPages +func (mr *MockECRAPIMockRecorder) DescribeRepositoriesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRepositoriesPages", reflect.TypeOf((*MockECRAPI)(nil).DescribeRepositoriesPages), arg0, arg1) +} + +// DescribeRepositoriesPagesWithContext mocks base method +func (m *MockECRAPI) DescribeRepositoriesPagesWithContext(arg0 context.Context, arg1 *ecr.DescribeRepositoriesInput, arg2 func(*ecr.DescribeRepositoriesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRepositoriesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeRepositoriesPagesWithContext indicates an expected call of DescribeRepositoriesPagesWithContext +func (mr *MockECRAPIMockRecorder) DescribeRepositoriesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRepositoriesPagesWithContext", reflect.TypeOf((*MockECRAPI)(nil).DescribeRepositoriesPagesWithContext), varargs...) +} + +// DescribeRepositoriesRequest mocks base method +func (m *MockECRAPI) DescribeRepositoriesRequest(arg0 *ecr.DescribeRepositoriesInput) (*request.Request, *ecr.DescribeRepositoriesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRepositoriesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.DescribeRepositoriesOutput) + return ret0, ret1 +} + +// DescribeRepositoriesRequest indicates an expected call of DescribeRepositoriesRequest +func (mr *MockECRAPIMockRecorder) DescribeRepositoriesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRepositoriesRequest", reflect.TypeOf((*MockECRAPI)(nil).DescribeRepositoriesRequest), arg0) +} + +// DescribeRepositoriesWithContext mocks base method +func (m *MockECRAPI) DescribeRepositoriesWithContext(arg0 context.Context, arg1 *ecr.DescribeRepositoriesInput, arg2 ...request.Option) (*ecr.DescribeRepositoriesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRepositoriesWithContext", varargs...) + ret0, _ := ret[0].(*ecr.DescribeRepositoriesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRepositoriesWithContext indicates an expected call of DescribeRepositoriesWithContext +func (mr *MockECRAPIMockRecorder) DescribeRepositoriesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRepositoriesWithContext", reflect.TypeOf((*MockECRAPI)(nil).DescribeRepositoriesWithContext), varargs...) +} + +// GetAuthorizationToken mocks base method +func (m *MockECRAPI) GetAuthorizationToken(arg0 *ecr.GetAuthorizationTokenInput) (*ecr.GetAuthorizationTokenOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAuthorizationToken", arg0) + ret0, _ := ret[0].(*ecr.GetAuthorizationTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAuthorizationToken indicates an expected call of GetAuthorizationToken +func (mr *MockECRAPIMockRecorder) GetAuthorizationToken(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizationToken", reflect.TypeOf((*MockECRAPI)(nil).GetAuthorizationToken), arg0) +} + +// GetAuthorizationTokenRequest mocks base method +func (m *MockECRAPI) GetAuthorizationTokenRequest(arg0 *ecr.GetAuthorizationTokenInput) (*request.Request, *ecr.GetAuthorizationTokenOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAuthorizationTokenRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.GetAuthorizationTokenOutput) + return ret0, ret1 +} + +// GetAuthorizationTokenRequest indicates an expected call of GetAuthorizationTokenRequest +func (mr *MockECRAPIMockRecorder) GetAuthorizationTokenRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizationTokenRequest", reflect.TypeOf((*MockECRAPI)(nil).GetAuthorizationTokenRequest), arg0) +} + +// GetAuthorizationTokenWithContext mocks base method +func (m *MockECRAPI) GetAuthorizationTokenWithContext(arg0 context.Context, arg1 *ecr.GetAuthorizationTokenInput, arg2 ...request.Option) (*ecr.GetAuthorizationTokenOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAuthorizationTokenWithContext", varargs...) + ret0, _ := ret[0].(*ecr.GetAuthorizationTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAuthorizationTokenWithContext indicates an expected call of GetAuthorizationTokenWithContext +func (mr *MockECRAPIMockRecorder) GetAuthorizationTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizationTokenWithContext", reflect.TypeOf((*MockECRAPI)(nil).GetAuthorizationTokenWithContext), varargs...) +} + +// GetDownloadUrlForLayer mocks base method +func (m *MockECRAPI) GetDownloadUrlForLayer(arg0 *ecr.GetDownloadUrlForLayerInput) (*ecr.GetDownloadUrlForLayerOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDownloadUrlForLayer", arg0) + ret0, _ := ret[0].(*ecr.GetDownloadUrlForLayerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDownloadUrlForLayer indicates an expected call of GetDownloadUrlForLayer +func (mr *MockECRAPIMockRecorder) GetDownloadUrlForLayer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDownloadUrlForLayer", reflect.TypeOf((*MockECRAPI)(nil).GetDownloadUrlForLayer), arg0) +} + +// GetDownloadUrlForLayerRequest mocks base method +func (m *MockECRAPI) GetDownloadUrlForLayerRequest(arg0 *ecr.GetDownloadUrlForLayerInput) (*request.Request, *ecr.GetDownloadUrlForLayerOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDownloadUrlForLayerRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.GetDownloadUrlForLayerOutput) + return ret0, ret1 +} + +// GetDownloadUrlForLayerRequest indicates an expected call of GetDownloadUrlForLayerRequest +func (mr *MockECRAPIMockRecorder) GetDownloadUrlForLayerRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDownloadUrlForLayerRequest", reflect.TypeOf((*MockECRAPI)(nil).GetDownloadUrlForLayerRequest), arg0) +} + +// GetDownloadUrlForLayerWithContext mocks base method +func (m *MockECRAPI) GetDownloadUrlForLayerWithContext(arg0 context.Context, arg1 *ecr.GetDownloadUrlForLayerInput, arg2 ...request.Option) (*ecr.GetDownloadUrlForLayerOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetDownloadUrlForLayerWithContext", varargs...) + ret0, _ := ret[0].(*ecr.GetDownloadUrlForLayerOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDownloadUrlForLayerWithContext indicates an expected call of GetDownloadUrlForLayerWithContext +func (mr *MockECRAPIMockRecorder) GetDownloadUrlForLayerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDownloadUrlForLayerWithContext", reflect.TypeOf((*MockECRAPI)(nil).GetDownloadUrlForLayerWithContext), varargs...) +} + +// GetLifecyclePolicy mocks base method +func (m *MockECRAPI) GetLifecyclePolicy(arg0 *ecr.GetLifecyclePolicyInput) (*ecr.GetLifecyclePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLifecyclePolicy", arg0) + ret0, _ := ret[0].(*ecr.GetLifecyclePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLifecyclePolicy indicates an expected call of GetLifecyclePolicy +func (mr *MockECRAPIMockRecorder) GetLifecyclePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLifecyclePolicy", reflect.TypeOf((*MockECRAPI)(nil).GetLifecyclePolicy), arg0) +} + +// GetLifecyclePolicyPreview mocks base method +func (m *MockECRAPI) GetLifecyclePolicyPreview(arg0 *ecr.GetLifecyclePolicyPreviewInput) (*ecr.GetLifecyclePolicyPreviewOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLifecyclePolicyPreview", arg0) + ret0, _ := ret[0].(*ecr.GetLifecyclePolicyPreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLifecyclePolicyPreview indicates an expected call of GetLifecyclePolicyPreview +func (mr *MockECRAPIMockRecorder) GetLifecyclePolicyPreview(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLifecyclePolicyPreview", reflect.TypeOf((*MockECRAPI)(nil).GetLifecyclePolicyPreview), arg0) +} + +// GetLifecyclePolicyPreviewPages mocks base method +func (m *MockECRAPI) GetLifecyclePolicyPreviewPages(arg0 *ecr.GetLifecyclePolicyPreviewInput, arg1 func(*ecr.GetLifecyclePolicyPreviewOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLifecyclePolicyPreviewPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetLifecyclePolicyPreviewPages indicates an expected call of GetLifecyclePolicyPreviewPages +func (mr *MockECRAPIMockRecorder) GetLifecyclePolicyPreviewPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLifecyclePolicyPreviewPages", reflect.TypeOf((*MockECRAPI)(nil).GetLifecyclePolicyPreviewPages), arg0, arg1) +} + +// GetLifecyclePolicyPreviewPagesWithContext mocks base method +func (m *MockECRAPI) GetLifecyclePolicyPreviewPagesWithContext(arg0 context.Context, arg1 *ecr.GetLifecyclePolicyPreviewInput, arg2 func(*ecr.GetLifecyclePolicyPreviewOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetLifecyclePolicyPreviewPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetLifecyclePolicyPreviewPagesWithContext indicates an expected call of GetLifecyclePolicyPreviewPagesWithContext +func (mr *MockECRAPIMockRecorder) GetLifecyclePolicyPreviewPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLifecyclePolicyPreviewPagesWithContext", reflect.TypeOf((*MockECRAPI)(nil).GetLifecyclePolicyPreviewPagesWithContext), varargs...) +} + +// GetLifecyclePolicyPreviewRequest mocks base method +func (m *MockECRAPI) GetLifecyclePolicyPreviewRequest(arg0 *ecr.GetLifecyclePolicyPreviewInput) (*request.Request, *ecr.GetLifecyclePolicyPreviewOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLifecyclePolicyPreviewRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.GetLifecyclePolicyPreviewOutput) + return ret0, ret1 +} + +// GetLifecyclePolicyPreviewRequest indicates an expected call of GetLifecyclePolicyPreviewRequest +func (mr *MockECRAPIMockRecorder) GetLifecyclePolicyPreviewRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLifecyclePolicyPreviewRequest", reflect.TypeOf((*MockECRAPI)(nil).GetLifecyclePolicyPreviewRequest), arg0) +} + +// GetLifecyclePolicyPreviewWithContext mocks base method +func (m *MockECRAPI) GetLifecyclePolicyPreviewWithContext(arg0 context.Context, arg1 *ecr.GetLifecyclePolicyPreviewInput, arg2 ...request.Option) (*ecr.GetLifecyclePolicyPreviewOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetLifecyclePolicyPreviewWithContext", varargs...) + ret0, _ := ret[0].(*ecr.GetLifecyclePolicyPreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLifecyclePolicyPreviewWithContext indicates an expected call of GetLifecyclePolicyPreviewWithContext +func (mr *MockECRAPIMockRecorder) GetLifecyclePolicyPreviewWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLifecyclePolicyPreviewWithContext", reflect.TypeOf((*MockECRAPI)(nil).GetLifecyclePolicyPreviewWithContext), varargs...) +} + +// GetLifecyclePolicyRequest mocks base method +func (m *MockECRAPI) GetLifecyclePolicyRequest(arg0 *ecr.GetLifecyclePolicyInput) (*request.Request, *ecr.GetLifecyclePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLifecyclePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.GetLifecyclePolicyOutput) + return ret0, ret1 +} + +// GetLifecyclePolicyRequest indicates an expected call of GetLifecyclePolicyRequest +func (mr *MockECRAPIMockRecorder) GetLifecyclePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLifecyclePolicyRequest", reflect.TypeOf((*MockECRAPI)(nil).GetLifecyclePolicyRequest), arg0) +} + +// GetLifecyclePolicyWithContext mocks base method +func (m *MockECRAPI) GetLifecyclePolicyWithContext(arg0 context.Context, arg1 *ecr.GetLifecyclePolicyInput, arg2 ...request.Option) (*ecr.GetLifecyclePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetLifecyclePolicyWithContext", varargs...) + ret0, _ := ret[0].(*ecr.GetLifecyclePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLifecyclePolicyWithContext indicates an expected call of GetLifecyclePolicyWithContext +func (mr *MockECRAPIMockRecorder) GetLifecyclePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLifecyclePolicyWithContext", reflect.TypeOf((*MockECRAPI)(nil).GetLifecyclePolicyWithContext), varargs...) +} + +// GetRepositoryPolicy mocks base method +func (m *MockECRAPI) GetRepositoryPolicy(arg0 *ecr.GetRepositoryPolicyInput) (*ecr.GetRepositoryPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRepositoryPolicy", arg0) + ret0, _ := ret[0].(*ecr.GetRepositoryPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRepositoryPolicy indicates an expected call of GetRepositoryPolicy +func (mr *MockECRAPIMockRecorder) GetRepositoryPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryPolicy", reflect.TypeOf((*MockECRAPI)(nil).GetRepositoryPolicy), arg0) +} + +// GetRepositoryPolicyRequest mocks base method +func (m *MockECRAPI) GetRepositoryPolicyRequest(arg0 *ecr.GetRepositoryPolicyInput) (*request.Request, *ecr.GetRepositoryPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRepositoryPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.GetRepositoryPolicyOutput) + return ret0, ret1 +} + +// GetRepositoryPolicyRequest indicates an expected call of GetRepositoryPolicyRequest +func (mr *MockECRAPIMockRecorder) GetRepositoryPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryPolicyRequest", reflect.TypeOf((*MockECRAPI)(nil).GetRepositoryPolicyRequest), arg0) +} + +// GetRepositoryPolicyWithContext mocks base method +func (m *MockECRAPI) GetRepositoryPolicyWithContext(arg0 context.Context, arg1 *ecr.GetRepositoryPolicyInput, arg2 ...request.Option) (*ecr.GetRepositoryPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetRepositoryPolicyWithContext", varargs...) + ret0, _ := ret[0].(*ecr.GetRepositoryPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRepositoryPolicyWithContext indicates an expected call of GetRepositoryPolicyWithContext +func (mr *MockECRAPIMockRecorder) GetRepositoryPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryPolicyWithContext", reflect.TypeOf((*MockECRAPI)(nil).GetRepositoryPolicyWithContext), varargs...) +} + +// InitiateLayerUpload mocks base method +func (m *MockECRAPI) InitiateLayerUpload(arg0 *ecr.InitiateLayerUploadInput) (*ecr.InitiateLayerUploadOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InitiateLayerUpload", arg0) + ret0, _ := ret[0].(*ecr.InitiateLayerUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InitiateLayerUpload indicates an expected call of InitiateLayerUpload +func (mr *MockECRAPIMockRecorder) InitiateLayerUpload(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitiateLayerUpload", reflect.TypeOf((*MockECRAPI)(nil).InitiateLayerUpload), arg0) +} + +// InitiateLayerUploadRequest mocks base method +func (m *MockECRAPI) InitiateLayerUploadRequest(arg0 *ecr.InitiateLayerUploadInput) (*request.Request, *ecr.InitiateLayerUploadOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InitiateLayerUploadRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.InitiateLayerUploadOutput) + return ret0, ret1 +} + +// InitiateLayerUploadRequest indicates an expected call of InitiateLayerUploadRequest +func (mr *MockECRAPIMockRecorder) InitiateLayerUploadRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitiateLayerUploadRequest", reflect.TypeOf((*MockECRAPI)(nil).InitiateLayerUploadRequest), arg0) +} + +// InitiateLayerUploadWithContext mocks base method +func (m *MockECRAPI) InitiateLayerUploadWithContext(arg0 context.Context, arg1 *ecr.InitiateLayerUploadInput, arg2 ...request.Option) (*ecr.InitiateLayerUploadOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "InitiateLayerUploadWithContext", varargs...) + ret0, _ := ret[0].(*ecr.InitiateLayerUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// InitiateLayerUploadWithContext indicates an expected call of InitiateLayerUploadWithContext +func (mr *MockECRAPIMockRecorder) InitiateLayerUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitiateLayerUploadWithContext", reflect.TypeOf((*MockECRAPI)(nil).InitiateLayerUploadWithContext), varargs...) +} + +// ListImages mocks base method +func (m *MockECRAPI) ListImages(arg0 *ecr.ListImagesInput) (*ecr.ListImagesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListImages", arg0) + ret0, _ := ret[0].(*ecr.ListImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListImages indicates an expected call of ListImages +func (mr *MockECRAPIMockRecorder) ListImages(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImages", reflect.TypeOf((*MockECRAPI)(nil).ListImages), arg0) +} + +// ListImagesPages mocks base method +func (m *MockECRAPI) ListImagesPages(arg0 *ecr.ListImagesInput, arg1 func(*ecr.ListImagesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListImagesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListImagesPages indicates an expected call of ListImagesPages +func (mr *MockECRAPIMockRecorder) ListImagesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesPages", reflect.TypeOf((*MockECRAPI)(nil).ListImagesPages), arg0, arg1) +} + +// ListImagesPagesWithContext mocks base method +func (m *MockECRAPI) ListImagesPagesWithContext(arg0 context.Context, arg1 *ecr.ListImagesInput, arg2 func(*ecr.ListImagesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListImagesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListImagesPagesWithContext indicates an expected call of ListImagesPagesWithContext +func (mr *MockECRAPIMockRecorder) ListImagesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesPagesWithContext", reflect.TypeOf((*MockECRAPI)(nil).ListImagesPagesWithContext), varargs...) +} + +// ListImagesRequest mocks base method +func (m *MockECRAPI) ListImagesRequest(arg0 *ecr.ListImagesInput) (*request.Request, *ecr.ListImagesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListImagesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.ListImagesOutput) + return ret0, ret1 +} + +// ListImagesRequest indicates an expected call of ListImagesRequest +func (mr *MockECRAPIMockRecorder) ListImagesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesRequest", reflect.TypeOf((*MockECRAPI)(nil).ListImagesRequest), arg0) +} + +// ListImagesWithContext mocks base method +func (m *MockECRAPI) ListImagesWithContext(arg0 context.Context, arg1 *ecr.ListImagesInput, arg2 ...request.Option) (*ecr.ListImagesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListImagesWithContext", varargs...) + ret0, _ := ret[0].(*ecr.ListImagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListImagesWithContext indicates an expected call of ListImagesWithContext +func (mr *MockECRAPIMockRecorder) ListImagesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesWithContext", reflect.TypeOf((*MockECRAPI)(nil).ListImagesWithContext), varargs...) +} + +// ListTagsForResource mocks base method +func (m *MockECRAPI) ListTagsForResource(arg0 *ecr.ListTagsForResourceInput) (*ecr.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResource", arg0) + ret0, _ := ret[0].(*ecr.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResource indicates an expected call of ListTagsForResource +func (mr *MockECRAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockECRAPI)(nil).ListTagsForResource), arg0) +} + +// ListTagsForResourceRequest mocks base method +func (m *MockECRAPI) ListTagsForResourceRequest(arg0 *ecr.ListTagsForResourceInput) (*request.Request, *ecr.ListTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.ListTagsForResourceOutput) + return ret0, ret1 +} + +// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest +func (mr *MockECRAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockECRAPI)(nil).ListTagsForResourceRequest), arg0) +} + +// ListTagsForResourceWithContext mocks base method +func (m *MockECRAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *ecr.ListTagsForResourceInput, arg2 ...request.Option) (*ecr.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) + ret0, _ := ret[0].(*ecr.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext +func (mr *MockECRAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockECRAPI)(nil).ListTagsForResourceWithContext), varargs...) +} + +// PutImage mocks base method +func (m *MockECRAPI) PutImage(arg0 *ecr.PutImageInput) (*ecr.PutImageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutImage", arg0) + ret0, _ := ret[0].(*ecr.PutImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutImage indicates an expected call of PutImage +func (mr *MockECRAPIMockRecorder) PutImage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImage", reflect.TypeOf((*MockECRAPI)(nil).PutImage), arg0) +} + +// PutImageRequest mocks base method +func (m *MockECRAPI) PutImageRequest(arg0 *ecr.PutImageInput) (*request.Request, *ecr.PutImageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutImageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.PutImageOutput) + return ret0, ret1 +} + +// PutImageRequest indicates an expected call of PutImageRequest +func (mr *MockECRAPIMockRecorder) PutImageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImageRequest", reflect.TypeOf((*MockECRAPI)(nil).PutImageRequest), arg0) +} + +// PutImageScanningConfiguration mocks base method +func (m *MockECRAPI) PutImageScanningConfiguration(arg0 *ecr.PutImageScanningConfigurationInput) (*ecr.PutImageScanningConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutImageScanningConfiguration", arg0) + ret0, _ := ret[0].(*ecr.PutImageScanningConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutImageScanningConfiguration indicates an expected call of PutImageScanningConfiguration +func (mr *MockECRAPIMockRecorder) PutImageScanningConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImageScanningConfiguration", reflect.TypeOf((*MockECRAPI)(nil).PutImageScanningConfiguration), arg0) +} + +// PutImageScanningConfigurationRequest mocks base method +func (m *MockECRAPI) PutImageScanningConfigurationRequest(arg0 *ecr.PutImageScanningConfigurationInput) (*request.Request, *ecr.PutImageScanningConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutImageScanningConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.PutImageScanningConfigurationOutput) + return ret0, ret1 +} + +// PutImageScanningConfigurationRequest indicates an expected call of PutImageScanningConfigurationRequest +func (mr *MockECRAPIMockRecorder) PutImageScanningConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImageScanningConfigurationRequest", reflect.TypeOf((*MockECRAPI)(nil).PutImageScanningConfigurationRequest), arg0) +} + +// PutImageScanningConfigurationWithContext mocks base method +func (m *MockECRAPI) PutImageScanningConfigurationWithContext(arg0 context.Context, arg1 *ecr.PutImageScanningConfigurationInput, arg2 ...request.Option) (*ecr.PutImageScanningConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutImageScanningConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*ecr.PutImageScanningConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutImageScanningConfigurationWithContext indicates an expected call of PutImageScanningConfigurationWithContext +func (mr *MockECRAPIMockRecorder) PutImageScanningConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImageScanningConfigurationWithContext", reflect.TypeOf((*MockECRAPI)(nil).PutImageScanningConfigurationWithContext), varargs...) +} + +// PutImageTagMutability mocks base method +func (m *MockECRAPI) PutImageTagMutability(arg0 *ecr.PutImageTagMutabilityInput) (*ecr.PutImageTagMutabilityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutImageTagMutability", arg0) + ret0, _ := ret[0].(*ecr.PutImageTagMutabilityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutImageTagMutability indicates an expected call of PutImageTagMutability +func (mr *MockECRAPIMockRecorder) PutImageTagMutability(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImageTagMutability", reflect.TypeOf((*MockECRAPI)(nil).PutImageTagMutability), arg0) +} + +// PutImageTagMutabilityRequest mocks base method +func (m *MockECRAPI) PutImageTagMutabilityRequest(arg0 *ecr.PutImageTagMutabilityInput) (*request.Request, *ecr.PutImageTagMutabilityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutImageTagMutabilityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.PutImageTagMutabilityOutput) + return ret0, ret1 +} + +// PutImageTagMutabilityRequest indicates an expected call of PutImageTagMutabilityRequest +func (mr *MockECRAPIMockRecorder) PutImageTagMutabilityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImageTagMutabilityRequest", reflect.TypeOf((*MockECRAPI)(nil).PutImageTagMutabilityRequest), arg0) +} + +// PutImageTagMutabilityWithContext mocks base method +func (m *MockECRAPI) PutImageTagMutabilityWithContext(arg0 context.Context, arg1 *ecr.PutImageTagMutabilityInput, arg2 ...request.Option) (*ecr.PutImageTagMutabilityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutImageTagMutabilityWithContext", varargs...) + ret0, _ := ret[0].(*ecr.PutImageTagMutabilityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutImageTagMutabilityWithContext indicates an expected call of PutImageTagMutabilityWithContext +func (mr *MockECRAPIMockRecorder) PutImageTagMutabilityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImageTagMutabilityWithContext", reflect.TypeOf((*MockECRAPI)(nil).PutImageTagMutabilityWithContext), varargs...) +} + +// PutImageWithContext mocks base method +func (m *MockECRAPI) PutImageWithContext(arg0 context.Context, arg1 *ecr.PutImageInput, arg2 ...request.Option) (*ecr.PutImageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutImageWithContext", varargs...) + ret0, _ := ret[0].(*ecr.PutImageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutImageWithContext indicates an expected call of PutImageWithContext +func (mr *MockECRAPIMockRecorder) PutImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutImageWithContext", reflect.TypeOf((*MockECRAPI)(nil).PutImageWithContext), varargs...) +} + +// PutLifecyclePolicy mocks base method +func (m *MockECRAPI) PutLifecyclePolicy(arg0 *ecr.PutLifecyclePolicyInput) (*ecr.PutLifecyclePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutLifecyclePolicy", arg0) + ret0, _ := ret[0].(*ecr.PutLifecyclePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutLifecyclePolicy indicates an expected call of PutLifecyclePolicy +func (mr *MockECRAPIMockRecorder) PutLifecyclePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecyclePolicy", reflect.TypeOf((*MockECRAPI)(nil).PutLifecyclePolicy), arg0) +} + +// PutLifecyclePolicyRequest mocks base method +func (m *MockECRAPI) PutLifecyclePolicyRequest(arg0 *ecr.PutLifecyclePolicyInput) (*request.Request, *ecr.PutLifecyclePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutLifecyclePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.PutLifecyclePolicyOutput) + return ret0, ret1 +} + +// PutLifecyclePolicyRequest indicates an expected call of PutLifecyclePolicyRequest +func (mr *MockECRAPIMockRecorder) PutLifecyclePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecyclePolicyRequest", reflect.TypeOf((*MockECRAPI)(nil).PutLifecyclePolicyRequest), arg0) +} + +// PutLifecyclePolicyWithContext mocks base method +func (m *MockECRAPI) PutLifecyclePolicyWithContext(arg0 context.Context, arg1 *ecr.PutLifecyclePolicyInput, arg2 ...request.Option) (*ecr.PutLifecyclePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutLifecyclePolicyWithContext", varargs...) + ret0, _ := ret[0].(*ecr.PutLifecyclePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutLifecyclePolicyWithContext indicates an expected call of PutLifecyclePolicyWithContext +func (mr *MockECRAPIMockRecorder) PutLifecyclePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecyclePolicyWithContext", reflect.TypeOf((*MockECRAPI)(nil).PutLifecyclePolicyWithContext), varargs...) +} + +// SetRepositoryPolicy mocks base method +func (m *MockECRAPI) SetRepositoryPolicy(arg0 *ecr.SetRepositoryPolicyInput) (*ecr.SetRepositoryPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRepositoryPolicy", arg0) + ret0, _ := ret[0].(*ecr.SetRepositoryPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetRepositoryPolicy indicates an expected call of SetRepositoryPolicy +func (mr *MockECRAPIMockRecorder) SetRepositoryPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepositoryPolicy", reflect.TypeOf((*MockECRAPI)(nil).SetRepositoryPolicy), arg0) +} + +// SetRepositoryPolicyRequest mocks base method +func (m *MockECRAPI) SetRepositoryPolicyRequest(arg0 *ecr.SetRepositoryPolicyInput) (*request.Request, *ecr.SetRepositoryPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRepositoryPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.SetRepositoryPolicyOutput) + return ret0, ret1 +} + +// SetRepositoryPolicyRequest indicates an expected call of SetRepositoryPolicyRequest +func (mr *MockECRAPIMockRecorder) SetRepositoryPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepositoryPolicyRequest", reflect.TypeOf((*MockECRAPI)(nil).SetRepositoryPolicyRequest), arg0) +} + +// SetRepositoryPolicyWithContext mocks base method +func (m *MockECRAPI) SetRepositoryPolicyWithContext(arg0 context.Context, arg1 *ecr.SetRepositoryPolicyInput, arg2 ...request.Option) (*ecr.SetRepositoryPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetRepositoryPolicyWithContext", varargs...) + ret0, _ := ret[0].(*ecr.SetRepositoryPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetRepositoryPolicyWithContext indicates an expected call of SetRepositoryPolicyWithContext +func (mr *MockECRAPIMockRecorder) SetRepositoryPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepositoryPolicyWithContext", reflect.TypeOf((*MockECRAPI)(nil).SetRepositoryPolicyWithContext), varargs...) +} + +// StartImageScan mocks base method +func (m *MockECRAPI) StartImageScan(arg0 *ecr.StartImageScanInput) (*ecr.StartImageScanOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartImageScan", arg0) + ret0, _ := ret[0].(*ecr.StartImageScanOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartImageScan indicates an expected call of StartImageScan +func (mr *MockECRAPIMockRecorder) StartImageScan(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartImageScan", reflect.TypeOf((*MockECRAPI)(nil).StartImageScan), arg0) +} + +// StartImageScanRequest mocks base method +func (m *MockECRAPI) StartImageScanRequest(arg0 *ecr.StartImageScanInput) (*request.Request, *ecr.StartImageScanOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartImageScanRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.StartImageScanOutput) + return ret0, ret1 +} + +// StartImageScanRequest indicates an expected call of StartImageScanRequest +func (mr *MockECRAPIMockRecorder) StartImageScanRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartImageScanRequest", reflect.TypeOf((*MockECRAPI)(nil).StartImageScanRequest), arg0) +} + +// StartImageScanWithContext mocks base method +func (m *MockECRAPI) StartImageScanWithContext(arg0 context.Context, arg1 *ecr.StartImageScanInput, arg2 ...request.Option) (*ecr.StartImageScanOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartImageScanWithContext", varargs...) + ret0, _ := ret[0].(*ecr.StartImageScanOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartImageScanWithContext indicates an expected call of StartImageScanWithContext +func (mr *MockECRAPIMockRecorder) StartImageScanWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartImageScanWithContext", reflect.TypeOf((*MockECRAPI)(nil).StartImageScanWithContext), varargs...) +} + +// StartLifecyclePolicyPreview mocks base method +func (m *MockECRAPI) StartLifecyclePolicyPreview(arg0 *ecr.StartLifecyclePolicyPreviewInput) (*ecr.StartLifecyclePolicyPreviewOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartLifecyclePolicyPreview", arg0) + ret0, _ := ret[0].(*ecr.StartLifecyclePolicyPreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartLifecyclePolicyPreview indicates an expected call of StartLifecyclePolicyPreview +func (mr *MockECRAPIMockRecorder) StartLifecyclePolicyPreview(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartLifecyclePolicyPreview", reflect.TypeOf((*MockECRAPI)(nil).StartLifecyclePolicyPreview), arg0) +} + +// StartLifecyclePolicyPreviewRequest mocks base method +func (m *MockECRAPI) StartLifecyclePolicyPreviewRequest(arg0 *ecr.StartLifecyclePolicyPreviewInput) (*request.Request, *ecr.StartLifecyclePolicyPreviewOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartLifecyclePolicyPreviewRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.StartLifecyclePolicyPreviewOutput) + return ret0, ret1 +} + +// StartLifecyclePolicyPreviewRequest indicates an expected call of StartLifecyclePolicyPreviewRequest +func (mr *MockECRAPIMockRecorder) StartLifecyclePolicyPreviewRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartLifecyclePolicyPreviewRequest", reflect.TypeOf((*MockECRAPI)(nil).StartLifecyclePolicyPreviewRequest), arg0) +} + +// StartLifecyclePolicyPreviewWithContext mocks base method +func (m *MockECRAPI) StartLifecyclePolicyPreviewWithContext(arg0 context.Context, arg1 *ecr.StartLifecyclePolicyPreviewInput, arg2 ...request.Option) (*ecr.StartLifecyclePolicyPreviewOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartLifecyclePolicyPreviewWithContext", varargs...) + ret0, _ := ret[0].(*ecr.StartLifecyclePolicyPreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartLifecyclePolicyPreviewWithContext indicates an expected call of StartLifecyclePolicyPreviewWithContext +func (mr *MockECRAPIMockRecorder) StartLifecyclePolicyPreviewWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartLifecyclePolicyPreviewWithContext", reflect.TypeOf((*MockECRAPI)(nil).StartLifecyclePolicyPreviewWithContext), varargs...) +} + +// TagResource mocks base method +func (m *MockECRAPI) TagResource(arg0 *ecr.TagResourceInput) (*ecr.TagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResource", arg0) + ret0, _ := ret[0].(*ecr.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResource indicates an expected call of TagResource +func (mr *MockECRAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockECRAPI)(nil).TagResource), arg0) +} + +// TagResourceRequest mocks base method +func (m *MockECRAPI) TagResourceRequest(arg0 *ecr.TagResourceInput) (*request.Request, *ecr.TagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.TagResourceOutput) + return ret0, ret1 +} + +// TagResourceRequest indicates an expected call of TagResourceRequest +func (mr *MockECRAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockECRAPI)(nil).TagResourceRequest), arg0) +} + +// TagResourceWithContext mocks base method +func (m *MockECRAPI) TagResourceWithContext(arg0 context.Context, arg1 *ecr.TagResourceInput, arg2 ...request.Option) (*ecr.TagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) + ret0, _ := ret[0].(*ecr.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResourceWithContext indicates an expected call of TagResourceWithContext +func (mr *MockECRAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockECRAPI)(nil).TagResourceWithContext), varargs...) +} + +// UntagResource mocks base method +func (m *MockECRAPI) UntagResource(arg0 *ecr.UntagResourceInput) (*ecr.UntagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResource", arg0) + ret0, _ := ret[0].(*ecr.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResource indicates an expected call of UntagResource +func (mr *MockECRAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockECRAPI)(nil).UntagResource), arg0) +} + +// UntagResourceRequest mocks base method +func (m *MockECRAPI) UntagResourceRequest(arg0 *ecr.UntagResourceInput) (*request.Request, *ecr.UntagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.UntagResourceOutput) + return ret0, ret1 +} + +// UntagResourceRequest indicates an expected call of UntagResourceRequest +func (mr *MockECRAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockECRAPI)(nil).UntagResourceRequest), arg0) +} + +// UntagResourceWithContext mocks base method +func (m *MockECRAPI) UntagResourceWithContext(arg0 context.Context, arg1 *ecr.UntagResourceInput, arg2 ...request.Option) (*ecr.UntagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) + ret0, _ := ret[0].(*ecr.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResourceWithContext indicates an expected call of UntagResourceWithContext +func (mr *MockECRAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockECRAPI)(nil).UntagResourceWithContext), varargs...) +} + +// UploadLayerPart mocks base method +func (m *MockECRAPI) UploadLayerPart(arg0 *ecr.UploadLayerPartInput) (*ecr.UploadLayerPartOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UploadLayerPart", arg0) + ret0, _ := ret[0].(*ecr.UploadLayerPartOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadLayerPart indicates an expected call of UploadLayerPart +func (mr *MockECRAPIMockRecorder) UploadLayerPart(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadLayerPart", reflect.TypeOf((*MockECRAPI)(nil).UploadLayerPart), arg0) +} + +// UploadLayerPartRequest mocks base method +func (m *MockECRAPI) UploadLayerPartRequest(arg0 *ecr.UploadLayerPartInput) (*request.Request, *ecr.UploadLayerPartOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UploadLayerPartRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*ecr.UploadLayerPartOutput) + return ret0, ret1 +} + +// UploadLayerPartRequest indicates an expected call of UploadLayerPartRequest +func (mr *MockECRAPIMockRecorder) UploadLayerPartRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadLayerPartRequest", reflect.TypeOf((*MockECRAPI)(nil).UploadLayerPartRequest), arg0) +} + +// UploadLayerPartWithContext mocks base method +func (m *MockECRAPI) UploadLayerPartWithContext(arg0 context.Context, arg1 *ecr.UploadLayerPartInput, arg2 ...request.Option) (*ecr.UploadLayerPartOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UploadLayerPartWithContext", varargs...) + ret0, _ := ret[0].(*ecr.UploadLayerPartOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadLayerPartWithContext indicates an expected call of UploadLayerPartWithContext +func (mr *MockECRAPIMockRecorder) UploadLayerPartWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadLayerPartWithContext", reflect.TypeOf((*MockECRAPI)(nil).UploadLayerPartWithContext), varargs...) +} + +// WaitUntilImageScanComplete mocks base method +func (m *MockECRAPI) WaitUntilImageScanComplete(arg0 *ecr.DescribeImageScanFindingsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilImageScanComplete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilImageScanComplete indicates an expected call of WaitUntilImageScanComplete +func (mr *MockECRAPIMockRecorder) WaitUntilImageScanComplete(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageScanComplete", reflect.TypeOf((*MockECRAPI)(nil).WaitUntilImageScanComplete), arg0) +} + +// WaitUntilImageScanCompleteWithContext mocks base method +func (m *MockECRAPI) WaitUntilImageScanCompleteWithContext(arg0 context.Context, arg1 *ecr.DescribeImageScanFindingsInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilImageScanCompleteWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilImageScanCompleteWithContext indicates an expected call of WaitUntilImageScanCompleteWithContext +func (mr *MockECRAPIMockRecorder) WaitUntilImageScanCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageScanCompleteWithContext", reflect.TypeOf((*MockECRAPI)(nil).WaitUntilImageScanCompleteWithContext), varargs...) +} + +// WaitUntilLifecyclePolicyPreviewComplete mocks base method +func (m *MockECRAPI) WaitUntilLifecyclePolicyPreviewComplete(arg0 *ecr.GetLifecyclePolicyPreviewInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilLifecyclePolicyPreviewComplete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilLifecyclePolicyPreviewComplete indicates an expected call of WaitUntilLifecyclePolicyPreviewComplete +func (mr *MockECRAPIMockRecorder) WaitUntilLifecyclePolicyPreviewComplete(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLifecyclePolicyPreviewComplete", reflect.TypeOf((*MockECRAPI)(nil).WaitUntilLifecyclePolicyPreviewComplete), arg0) +} + +// WaitUntilLifecyclePolicyPreviewCompleteWithContext mocks base method +func (m *MockECRAPI) WaitUntilLifecyclePolicyPreviewCompleteWithContext(arg0 context.Context, arg1 *ecr.GetLifecyclePolicyPreviewInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilLifecyclePolicyPreviewCompleteWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilLifecyclePolicyPreviewCompleteWithContext indicates an expected call of WaitUntilLifecyclePolicyPreviewCompleteWithContext +func (mr *MockECRAPIMockRecorder) WaitUntilLifecyclePolicyPreviewCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLifecyclePolicyPreviewCompleteWithContext", reflect.TypeOf((*MockECRAPI)(nil).WaitUntilLifecyclePolicyPreviewCompleteWithContext), varargs...) +} diff --git a/pkg/mocks/mock_health.go b/pkg/mocks/mock_health.go new file mode 100644 index 0000000..35bef8f --- /dev/null +++ b/pkg/mocks/mock_health.go @@ -0,0 +1,917 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/health/healthiface (interfaces: HealthAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + health "github.com/aws/aws-sdk-go/service/health" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockHealthAPI is a mock of HealthAPI interface +type MockHealthAPI struct { + ctrl *gomock.Controller + recorder *MockHealthAPIMockRecorder +} + +// MockHealthAPIMockRecorder is the mock recorder for MockHealthAPI +type MockHealthAPIMockRecorder struct { + mock *MockHealthAPI +} + +// NewMockHealthAPI creates a new mock instance +func NewMockHealthAPI(ctrl *gomock.Controller) *MockHealthAPI { + mock := &MockHealthAPI{ctrl: ctrl} + mock.recorder = &MockHealthAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockHealthAPI) EXPECT() *MockHealthAPIMockRecorder { + return m.recorder +} + +// DescribeAffectedAccountsForOrganization mocks base method +func (m *MockHealthAPI) DescribeAffectedAccountsForOrganization(arg0 *health.DescribeAffectedAccountsForOrganizationInput) (*health.DescribeAffectedAccountsForOrganizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedAccountsForOrganization", arg0) + ret0, _ := ret[0].(*health.DescribeAffectedAccountsForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAffectedAccountsForOrganization indicates an expected call of DescribeAffectedAccountsForOrganization +func (mr *MockHealthAPIMockRecorder) DescribeAffectedAccountsForOrganization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedAccountsForOrganization", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedAccountsForOrganization), arg0) +} + +// DescribeAffectedAccountsForOrganizationPages mocks base method +func (m *MockHealthAPI) DescribeAffectedAccountsForOrganizationPages(arg0 *health.DescribeAffectedAccountsForOrganizationInput, arg1 func(*health.DescribeAffectedAccountsForOrganizationOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedAccountsForOrganizationPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAffectedAccountsForOrganizationPages indicates an expected call of DescribeAffectedAccountsForOrganizationPages +func (mr *MockHealthAPIMockRecorder) DescribeAffectedAccountsForOrganizationPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedAccountsForOrganizationPages", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedAccountsForOrganizationPages), arg0, arg1) +} + +// DescribeAffectedAccountsForOrganizationPagesWithContext mocks base method +func (m *MockHealthAPI) DescribeAffectedAccountsForOrganizationPagesWithContext(arg0 context.Context, arg1 *health.DescribeAffectedAccountsForOrganizationInput, arg2 func(*health.DescribeAffectedAccountsForOrganizationOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAffectedAccountsForOrganizationPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAffectedAccountsForOrganizationPagesWithContext indicates an expected call of DescribeAffectedAccountsForOrganizationPagesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeAffectedAccountsForOrganizationPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedAccountsForOrganizationPagesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedAccountsForOrganizationPagesWithContext), varargs...) +} + +// DescribeAffectedAccountsForOrganizationRequest mocks base method +func (m *MockHealthAPI) DescribeAffectedAccountsForOrganizationRequest(arg0 *health.DescribeAffectedAccountsForOrganizationInput) (*request.Request, *health.DescribeAffectedAccountsForOrganizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedAccountsForOrganizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeAffectedAccountsForOrganizationOutput) + return ret0, ret1 +} + +// DescribeAffectedAccountsForOrganizationRequest indicates an expected call of DescribeAffectedAccountsForOrganizationRequest +func (mr *MockHealthAPIMockRecorder) DescribeAffectedAccountsForOrganizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedAccountsForOrganizationRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedAccountsForOrganizationRequest), arg0) +} + +// DescribeAffectedAccountsForOrganizationWithContext mocks base method +func (m *MockHealthAPI) DescribeAffectedAccountsForOrganizationWithContext(arg0 context.Context, arg1 *health.DescribeAffectedAccountsForOrganizationInput, arg2 ...request.Option) (*health.DescribeAffectedAccountsForOrganizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAffectedAccountsForOrganizationWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeAffectedAccountsForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAffectedAccountsForOrganizationWithContext indicates an expected call of DescribeAffectedAccountsForOrganizationWithContext +func (mr *MockHealthAPIMockRecorder) DescribeAffectedAccountsForOrganizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedAccountsForOrganizationWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedAccountsForOrganizationWithContext), varargs...) +} + +// DescribeAffectedEntities mocks base method +func (m *MockHealthAPI) DescribeAffectedEntities(arg0 *health.DescribeAffectedEntitiesInput) (*health.DescribeAffectedEntitiesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedEntities", arg0) + ret0, _ := ret[0].(*health.DescribeAffectedEntitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAffectedEntities indicates an expected call of DescribeAffectedEntities +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntities(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntities", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntities), arg0) +} + +// DescribeAffectedEntitiesForOrganization mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesForOrganization(arg0 *health.DescribeAffectedEntitiesForOrganizationInput) (*health.DescribeAffectedEntitiesForOrganizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesForOrganization", arg0) + ret0, _ := ret[0].(*health.DescribeAffectedEntitiesForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAffectedEntitiesForOrganization indicates an expected call of DescribeAffectedEntitiesForOrganization +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesForOrganization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesForOrganization", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesForOrganization), arg0) +} + +// DescribeAffectedEntitiesForOrganizationPages mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesForOrganizationPages(arg0 *health.DescribeAffectedEntitiesForOrganizationInput, arg1 func(*health.DescribeAffectedEntitiesForOrganizationOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesForOrganizationPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAffectedEntitiesForOrganizationPages indicates an expected call of DescribeAffectedEntitiesForOrganizationPages +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesForOrganizationPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesForOrganizationPages", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesForOrganizationPages), arg0, arg1) +} + +// DescribeAffectedEntitiesForOrganizationPagesWithContext mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesForOrganizationPagesWithContext(arg0 context.Context, arg1 *health.DescribeAffectedEntitiesForOrganizationInput, arg2 func(*health.DescribeAffectedEntitiesForOrganizationOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesForOrganizationPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAffectedEntitiesForOrganizationPagesWithContext indicates an expected call of DescribeAffectedEntitiesForOrganizationPagesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesForOrganizationPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesForOrganizationPagesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesForOrganizationPagesWithContext), varargs...) +} + +// DescribeAffectedEntitiesForOrganizationRequest mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesForOrganizationRequest(arg0 *health.DescribeAffectedEntitiesForOrganizationInput) (*request.Request, *health.DescribeAffectedEntitiesForOrganizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesForOrganizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeAffectedEntitiesForOrganizationOutput) + return ret0, ret1 +} + +// DescribeAffectedEntitiesForOrganizationRequest indicates an expected call of DescribeAffectedEntitiesForOrganizationRequest +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesForOrganizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesForOrganizationRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesForOrganizationRequest), arg0) +} + +// DescribeAffectedEntitiesForOrganizationWithContext mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesForOrganizationWithContext(arg0 context.Context, arg1 *health.DescribeAffectedEntitiesForOrganizationInput, arg2 ...request.Option) (*health.DescribeAffectedEntitiesForOrganizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesForOrganizationWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeAffectedEntitiesForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAffectedEntitiesForOrganizationWithContext indicates an expected call of DescribeAffectedEntitiesForOrganizationWithContext +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesForOrganizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesForOrganizationWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesForOrganizationWithContext), varargs...) +} + +// DescribeAffectedEntitiesPages mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesPages(arg0 *health.DescribeAffectedEntitiesInput, arg1 func(*health.DescribeAffectedEntitiesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAffectedEntitiesPages indicates an expected call of DescribeAffectedEntitiesPages +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesPages", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesPages), arg0, arg1) +} + +// DescribeAffectedEntitiesPagesWithContext mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesPagesWithContext(arg0 context.Context, arg1 *health.DescribeAffectedEntitiesInput, arg2 func(*health.DescribeAffectedEntitiesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAffectedEntitiesPagesWithContext indicates an expected call of DescribeAffectedEntitiesPagesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesPagesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesPagesWithContext), varargs...) +} + +// DescribeAffectedEntitiesRequest mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesRequest(arg0 *health.DescribeAffectedEntitiesInput) (*request.Request, *health.DescribeAffectedEntitiesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeAffectedEntitiesOutput) + return ret0, ret1 +} + +// DescribeAffectedEntitiesRequest indicates an expected call of DescribeAffectedEntitiesRequest +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesRequest), arg0) +} + +// DescribeAffectedEntitiesWithContext mocks base method +func (m *MockHealthAPI) DescribeAffectedEntitiesWithContext(arg0 context.Context, arg1 *health.DescribeAffectedEntitiesInput, arg2 ...request.Option) (*health.DescribeAffectedEntitiesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAffectedEntitiesWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeAffectedEntitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAffectedEntitiesWithContext indicates an expected call of DescribeAffectedEntitiesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeAffectedEntitiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAffectedEntitiesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeAffectedEntitiesWithContext), varargs...) +} + +// DescribeEntityAggregates mocks base method +func (m *MockHealthAPI) DescribeEntityAggregates(arg0 *health.DescribeEntityAggregatesInput) (*health.DescribeEntityAggregatesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEntityAggregates", arg0) + ret0, _ := ret[0].(*health.DescribeEntityAggregatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEntityAggregates indicates an expected call of DescribeEntityAggregates +func (mr *MockHealthAPIMockRecorder) DescribeEntityAggregates(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEntityAggregates", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEntityAggregates), arg0) +} + +// DescribeEntityAggregatesRequest mocks base method +func (m *MockHealthAPI) DescribeEntityAggregatesRequest(arg0 *health.DescribeEntityAggregatesInput) (*request.Request, *health.DescribeEntityAggregatesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEntityAggregatesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeEntityAggregatesOutput) + return ret0, ret1 +} + +// DescribeEntityAggregatesRequest indicates an expected call of DescribeEntityAggregatesRequest +func (mr *MockHealthAPIMockRecorder) DescribeEntityAggregatesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEntityAggregatesRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEntityAggregatesRequest), arg0) +} + +// DescribeEntityAggregatesWithContext mocks base method +func (m *MockHealthAPI) DescribeEntityAggregatesWithContext(arg0 context.Context, arg1 *health.DescribeEntityAggregatesInput, arg2 ...request.Option) (*health.DescribeEntityAggregatesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEntityAggregatesWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeEntityAggregatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEntityAggregatesWithContext indicates an expected call of DescribeEntityAggregatesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEntityAggregatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEntityAggregatesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEntityAggregatesWithContext), varargs...) +} + +// DescribeEventAggregates mocks base method +func (m *MockHealthAPI) DescribeEventAggregates(arg0 *health.DescribeEventAggregatesInput) (*health.DescribeEventAggregatesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventAggregates", arg0) + ret0, _ := ret[0].(*health.DescribeEventAggregatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventAggregates indicates an expected call of DescribeEventAggregates +func (mr *MockHealthAPIMockRecorder) DescribeEventAggregates(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventAggregates", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventAggregates), arg0) +} + +// DescribeEventAggregatesPages mocks base method +func (m *MockHealthAPI) DescribeEventAggregatesPages(arg0 *health.DescribeEventAggregatesInput, arg1 func(*health.DescribeEventAggregatesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventAggregatesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEventAggregatesPages indicates an expected call of DescribeEventAggregatesPages +func (mr *MockHealthAPIMockRecorder) DescribeEventAggregatesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventAggregatesPages", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventAggregatesPages), arg0, arg1) +} + +// DescribeEventAggregatesPagesWithContext mocks base method +func (m *MockHealthAPI) DescribeEventAggregatesPagesWithContext(arg0 context.Context, arg1 *health.DescribeEventAggregatesInput, arg2 func(*health.DescribeEventAggregatesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventAggregatesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEventAggregatesPagesWithContext indicates an expected call of DescribeEventAggregatesPagesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventAggregatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventAggregatesPagesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventAggregatesPagesWithContext), varargs...) +} + +// DescribeEventAggregatesRequest mocks base method +func (m *MockHealthAPI) DescribeEventAggregatesRequest(arg0 *health.DescribeEventAggregatesInput) (*request.Request, *health.DescribeEventAggregatesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventAggregatesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeEventAggregatesOutput) + return ret0, ret1 +} + +// DescribeEventAggregatesRequest indicates an expected call of DescribeEventAggregatesRequest +func (mr *MockHealthAPIMockRecorder) DescribeEventAggregatesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventAggregatesRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventAggregatesRequest), arg0) +} + +// DescribeEventAggregatesWithContext mocks base method +func (m *MockHealthAPI) DescribeEventAggregatesWithContext(arg0 context.Context, arg1 *health.DescribeEventAggregatesInput, arg2 ...request.Option) (*health.DescribeEventAggregatesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventAggregatesWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeEventAggregatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventAggregatesWithContext indicates an expected call of DescribeEventAggregatesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventAggregatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventAggregatesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventAggregatesWithContext), varargs...) +} + +// DescribeEventDetails mocks base method +func (m *MockHealthAPI) DescribeEventDetails(arg0 *health.DescribeEventDetailsInput) (*health.DescribeEventDetailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventDetails", arg0) + ret0, _ := ret[0].(*health.DescribeEventDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventDetails indicates an expected call of DescribeEventDetails +func (mr *MockHealthAPIMockRecorder) DescribeEventDetails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventDetails", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventDetails), arg0) +} + +// DescribeEventDetailsForOrganization mocks base method +func (m *MockHealthAPI) DescribeEventDetailsForOrganization(arg0 *health.DescribeEventDetailsForOrganizationInput) (*health.DescribeEventDetailsForOrganizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventDetailsForOrganization", arg0) + ret0, _ := ret[0].(*health.DescribeEventDetailsForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventDetailsForOrganization indicates an expected call of DescribeEventDetailsForOrganization +func (mr *MockHealthAPIMockRecorder) DescribeEventDetailsForOrganization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventDetailsForOrganization", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventDetailsForOrganization), arg0) +} + +// DescribeEventDetailsForOrganizationRequest mocks base method +func (m *MockHealthAPI) DescribeEventDetailsForOrganizationRequest(arg0 *health.DescribeEventDetailsForOrganizationInput) (*request.Request, *health.DescribeEventDetailsForOrganizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventDetailsForOrganizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeEventDetailsForOrganizationOutput) + return ret0, ret1 +} + +// DescribeEventDetailsForOrganizationRequest indicates an expected call of DescribeEventDetailsForOrganizationRequest +func (mr *MockHealthAPIMockRecorder) DescribeEventDetailsForOrganizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventDetailsForOrganizationRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventDetailsForOrganizationRequest), arg0) +} + +// DescribeEventDetailsForOrganizationWithContext mocks base method +func (m *MockHealthAPI) DescribeEventDetailsForOrganizationWithContext(arg0 context.Context, arg1 *health.DescribeEventDetailsForOrganizationInput, arg2 ...request.Option) (*health.DescribeEventDetailsForOrganizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventDetailsForOrganizationWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeEventDetailsForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventDetailsForOrganizationWithContext indicates an expected call of DescribeEventDetailsForOrganizationWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventDetailsForOrganizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventDetailsForOrganizationWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventDetailsForOrganizationWithContext), varargs...) +} + +// DescribeEventDetailsRequest mocks base method +func (m *MockHealthAPI) DescribeEventDetailsRequest(arg0 *health.DescribeEventDetailsInput) (*request.Request, *health.DescribeEventDetailsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventDetailsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeEventDetailsOutput) + return ret0, ret1 +} + +// DescribeEventDetailsRequest indicates an expected call of DescribeEventDetailsRequest +func (mr *MockHealthAPIMockRecorder) DescribeEventDetailsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventDetailsRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventDetailsRequest), arg0) +} + +// DescribeEventDetailsWithContext mocks base method +func (m *MockHealthAPI) DescribeEventDetailsWithContext(arg0 context.Context, arg1 *health.DescribeEventDetailsInput, arg2 ...request.Option) (*health.DescribeEventDetailsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventDetailsWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeEventDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventDetailsWithContext indicates an expected call of DescribeEventDetailsWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventDetailsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventDetailsWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventDetailsWithContext), varargs...) +} + +// DescribeEventTypes mocks base method +func (m *MockHealthAPI) DescribeEventTypes(arg0 *health.DescribeEventTypesInput) (*health.DescribeEventTypesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventTypes", arg0) + ret0, _ := ret[0].(*health.DescribeEventTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventTypes indicates an expected call of DescribeEventTypes +func (mr *MockHealthAPIMockRecorder) DescribeEventTypes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventTypes", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventTypes), arg0) +} + +// DescribeEventTypesPages mocks base method +func (m *MockHealthAPI) DescribeEventTypesPages(arg0 *health.DescribeEventTypesInput, arg1 func(*health.DescribeEventTypesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventTypesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEventTypesPages indicates an expected call of DescribeEventTypesPages +func (mr *MockHealthAPIMockRecorder) DescribeEventTypesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventTypesPages", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventTypesPages), arg0, arg1) +} + +// DescribeEventTypesPagesWithContext mocks base method +func (m *MockHealthAPI) DescribeEventTypesPagesWithContext(arg0 context.Context, arg1 *health.DescribeEventTypesInput, arg2 func(*health.DescribeEventTypesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventTypesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEventTypesPagesWithContext indicates an expected call of DescribeEventTypesPagesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventTypesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventTypesPagesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventTypesPagesWithContext), varargs...) +} + +// DescribeEventTypesRequest mocks base method +func (m *MockHealthAPI) DescribeEventTypesRequest(arg0 *health.DescribeEventTypesInput) (*request.Request, *health.DescribeEventTypesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventTypesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeEventTypesOutput) + return ret0, ret1 +} + +// DescribeEventTypesRequest indicates an expected call of DescribeEventTypesRequest +func (mr *MockHealthAPIMockRecorder) DescribeEventTypesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventTypesRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventTypesRequest), arg0) +} + +// DescribeEventTypesWithContext mocks base method +func (m *MockHealthAPI) DescribeEventTypesWithContext(arg0 context.Context, arg1 *health.DescribeEventTypesInput, arg2 ...request.Option) (*health.DescribeEventTypesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventTypesWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeEventTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventTypesWithContext indicates an expected call of DescribeEventTypesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventTypesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventTypesWithContext), varargs...) +} + +// DescribeEvents mocks base method +func (m *MockHealthAPI) DescribeEvents(arg0 *health.DescribeEventsInput) (*health.DescribeEventsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEvents", arg0) + ret0, _ := ret[0].(*health.DescribeEventsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEvents indicates an expected call of DescribeEvents +func (mr *MockHealthAPIMockRecorder) DescribeEvents(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEvents", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEvents), arg0) +} + +// DescribeEventsForOrganization mocks base method +func (m *MockHealthAPI) DescribeEventsForOrganization(arg0 *health.DescribeEventsForOrganizationInput) (*health.DescribeEventsForOrganizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventsForOrganization", arg0) + ret0, _ := ret[0].(*health.DescribeEventsForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventsForOrganization indicates an expected call of DescribeEventsForOrganization +func (mr *MockHealthAPIMockRecorder) DescribeEventsForOrganization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsForOrganization", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsForOrganization), arg0) +} + +// DescribeEventsForOrganizationPages mocks base method +func (m *MockHealthAPI) DescribeEventsForOrganizationPages(arg0 *health.DescribeEventsForOrganizationInput, arg1 func(*health.DescribeEventsForOrganizationOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventsForOrganizationPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEventsForOrganizationPages indicates an expected call of DescribeEventsForOrganizationPages +func (mr *MockHealthAPIMockRecorder) DescribeEventsForOrganizationPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsForOrganizationPages", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsForOrganizationPages), arg0, arg1) +} + +// DescribeEventsForOrganizationPagesWithContext mocks base method +func (m *MockHealthAPI) DescribeEventsForOrganizationPagesWithContext(arg0 context.Context, arg1 *health.DescribeEventsForOrganizationInput, arg2 func(*health.DescribeEventsForOrganizationOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventsForOrganizationPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEventsForOrganizationPagesWithContext indicates an expected call of DescribeEventsForOrganizationPagesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventsForOrganizationPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsForOrganizationPagesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsForOrganizationPagesWithContext), varargs...) +} + +// DescribeEventsForOrganizationRequest mocks base method +func (m *MockHealthAPI) DescribeEventsForOrganizationRequest(arg0 *health.DescribeEventsForOrganizationInput) (*request.Request, *health.DescribeEventsForOrganizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventsForOrganizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeEventsForOrganizationOutput) + return ret0, ret1 +} + +// DescribeEventsForOrganizationRequest indicates an expected call of DescribeEventsForOrganizationRequest +func (mr *MockHealthAPIMockRecorder) DescribeEventsForOrganizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsForOrganizationRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsForOrganizationRequest), arg0) +} + +// DescribeEventsForOrganizationWithContext mocks base method +func (m *MockHealthAPI) DescribeEventsForOrganizationWithContext(arg0 context.Context, arg1 *health.DescribeEventsForOrganizationInput, arg2 ...request.Option) (*health.DescribeEventsForOrganizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventsForOrganizationWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeEventsForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventsForOrganizationWithContext indicates an expected call of DescribeEventsForOrganizationWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventsForOrganizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsForOrganizationWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsForOrganizationWithContext), varargs...) +} + +// DescribeEventsPages mocks base method +func (m *MockHealthAPI) DescribeEventsPages(arg0 *health.DescribeEventsInput, arg1 func(*health.DescribeEventsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEventsPages indicates an expected call of DescribeEventsPages +func (mr *MockHealthAPIMockRecorder) DescribeEventsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsPages", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsPages), arg0, arg1) +} + +// DescribeEventsPagesWithContext mocks base method +func (m *MockHealthAPI) DescribeEventsPagesWithContext(arg0 context.Context, arg1 *health.DescribeEventsInput, arg2 func(*health.DescribeEventsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeEventsPagesWithContext indicates an expected call of DescribeEventsPagesWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsPagesWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsPagesWithContext), varargs...) +} + +// DescribeEventsRequest mocks base method +func (m *MockHealthAPI) DescribeEventsRequest(arg0 *health.DescribeEventsInput) (*request.Request, *health.DescribeEventsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeEventsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeEventsOutput) + return ret0, ret1 +} + +// DescribeEventsRequest indicates an expected call of DescribeEventsRequest +func (mr *MockHealthAPIMockRecorder) DescribeEventsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsRequest), arg0) +} + +// DescribeEventsWithContext mocks base method +func (m *MockHealthAPI) DescribeEventsWithContext(arg0 context.Context, arg1 *health.DescribeEventsInput, arg2 ...request.Option) (*health.DescribeEventsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeEventsWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeEventsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeEventsWithContext indicates an expected call of DescribeEventsWithContext +func (mr *MockHealthAPIMockRecorder) DescribeEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeEventsWithContext), varargs...) +} + +// DescribeHealthServiceStatusForOrganization mocks base method +func (m *MockHealthAPI) DescribeHealthServiceStatusForOrganization(arg0 *health.DescribeHealthServiceStatusForOrganizationInput) (*health.DescribeHealthServiceStatusForOrganizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHealthServiceStatusForOrganization", arg0) + ret0, _ := ret[0].(*health.DescribeHealthServiceStatusForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeHealthServiceStatusForOrganization indicates an expected call of DescribeHealthServiceStatusForOrganization +func (mr *MockHealthAPIMockRecorder) DescribeHealthServiceStatusForOrganization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHealthServiceStatusForOrganization", reflect.TypeOf((*MockHealthAPI)(nil).DescribeHealthServiceStatusForOrganization), arg0) +} + +// DescribeHealthServiceStatusForOrganizationRequest mocks base method +func (m *MockHealthAPI) DescribeHealthServiceStatusForOrganizationRequest(arg0 *health.DescribeHealthServiceStatusForOrganizationInput) (*request.Request, *health.DescribeHealthServiceStatusForOrganizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeHealthServiceStatusForOrganizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DescribeHealthServiceStatusForOrganizationOutput) + return ret0, ret1 +} + +// DescribeHealthServiceStatusForOrganizationRequest indicates an expected call of DescribeHealthServiceStatusForOrganizationRequest +func (mr *MockHealthAPIMockRecorder) DescribeHealthServiceStatusForOrganizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHealthServiceStatusForOrganizationRequest", reflect.TypeOf((*MockHealthAPI)(nil).DescribeHealthServiceStatusForOrganizationRequest), arg0) +} + +// DescribeHealthServiceStatusForOrganizationWithContext mocks base method +func (m *MockHealthAPI) DescribeHealthServiceStatusForOrganizationWithContext(arg0 context.Context, arg1 *health.DescribeHealthServiceStatusForOrganizationInput, arg2 ...request.Option) (*health.DescribeHealthServiceStatusForOrganizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeHealthServiceStatusForOrganizationWithContext", varargs...) + ret0, _ := ret[0].(*health.DescribeHealthServiceStatusForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeHealthServiceStatusForOrganizationWithContext indicates an expected call of DescribeHealthServiceStatusForOrganizationWithContext +func (mr *MockHealthAPIMockRecorder) DescribeHealthServiceStatusForOrganizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHealthServiceStatusForOrganizationWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DescribeHealthServiceStatusForOrganizationWithContext), varargs...) +} + +// DisableHealthServiceAccessForOrganization mocks base method +func (m *MockHealthAPI) DisableHealthServiceAccessForOrganization(arg0 *health.DisableHealthServiceAccessForOrganizationInput) (*health.DisableHealthServiceAccessForOrganizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableHealthServiceAccessForOrganization", arg0) + ret0, _ := ret[0].(*health.DisableHealthServiceAccessForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableHealthServiceAccessForOrganization indicates an expected call of DisableHealthServiceAccessForOrganization +func (mr *MockHealthAPIMockRecorder) DisableHealthServiceAccessForOrganization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableHealthServiceAccessForOrganization", reflect.TypeOf((*MockHealthAPI)(nil).DisableHealthServiceAccessForOrganization), arg0) +} + +// DisableHealthServiceAccessForOrganizationRequest mocks base method +func (m *MockHealthAPI) DisableHealthServiceAccessForOrganizationRequest(arg0 *health.DisableHealthServiceAccessForOrganizationInput) (*request.Request, *health.DisableHealthServiceAccessForOrganizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableHealthServiceAccessForOrganizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.DisableHealthServiceAccessForOrganizationOutput) + return ret0, ret1 +} + +// DisableHealthServiceAccessForOrganizationRequest indicates an expected call of DisableHealthServiceAccessForOrganizationRequest +func (mr *MockHealthAPIMockRecorder) DisableHealthServiceAccessForOrganizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableHealthServiceAccessForOrganizationRequest", reflect.TypeOf((*MockHealthAPI)(nil).DisableHealthServiceAccessForOrganizationRequest), arg0) +} + +// DisableHealthServiceAccessForOrganizationWithContext mocks base method +func (m *MockHealthAPI) DisableHealthServiceAccessForOrganizationWithContext(arg0 context.Context, arg1 *health.DisableHealthServiceAccessForOrganizationInput, arg2 ...request.Option) (*health.DisableHealthServiceAccessForOrganizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableHealthServiceAccessForOrganizationWithContext", varargs...) + ret0, _ := ret[0].(*health.DisableHealthServiceAccessForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableHealthServiceAccessForOrganizationWithContext indicates an expected call of DisableHealthServiceAccessForOrganizationWithContext +func (mr *MockHealthAPIMockRecorder) DisableHealthServiceAccessForOrganizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableHealthServiceAccessForOrganizationWithContext", reflect.TypeOf((*MockHealthAPI)(nil).DisableHealthServiceAccessForOrganizationWithContext), varargs...) +} + +// EnableHealthServiceAccessForOrganization mocks base method +func (m *MockHealthAPI) EnableHealthServiceAccessForOrganization(arg0 *health.EnableHealthServiceAccessForOrganizationInput) (*health.EnableHealthServiceAccessForOrganizationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableHealthServiceAccessForOrganization", arg0) + ret0, _ := ret[0].(*health.EnableHealthServiceAccessForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableHealthServiceAccessForOrganization indicates an expected call of EnableHealthServiceAccessForOrganization +func (mr *MockHealthAPIMockRecorder) EnableHealthServiceAccessForOrganization(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHealthServiceAccessForOrganization", reflect.TypeOf((*MockHealthAPI)(nil).EnableHealthServiceAccessForOrganization), arg0) +} + +// EnableHealthServiceAccessForOrganizationRequest mocks base method +func (m *MockHealthAPI) EnableHealthServiceAccessForOrganizationRequest(arg0 *health.EnableHealthServiceAccessForOrganizationInput) (*request.Request, *health.EnableHealthServiceAccessForOrganizationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableHealthServiceAccessForOrganizationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*health.EnableHealthServiceAccessForOrganizationOutput) + return ret0, ret1 +} + +// EnableHealthServiceAccessForOrganizationRequest indicates an expected call of EnableHealthServiceAccessForOrganizationRequest +func (mr *MockHealthAPIMockRecorder) EnableHealthServiceAccessForOrganizationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHealthServiceAccessForOrganizationRequest", reflect.TypeOf((*MockHealthAPI)(nil).EnableHealthServiceAccessForOrganizationRequest), arg0) +} + +// EnableHealthServiceAccessForOrganizationWithContext mocks base method +func (m *MockHealthAPI) EnableHealthServiceAccessForOrganizationWithContext(arg0 context.Context, arg1 *health.EnableHealthServiceAccessForOrganizationInput, arg2 ...request.Option) (*health.EnableHealthServiceAccessForOrganizationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableHealthServiceAccessForOrganizationWithContext", varargs...) + ret0, _ := ret[0].(*health.EnableHealthServiceAccessForOrganizationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableHealthServiceAccessForOrganizationWithContext indicates an expected call of EnableHealthServiceAccessForOrganizationWithContext +func (mr *MockHealthAPIMockRecorder) EnableHealthServiceAccessForOrganizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHealthServiceAccessForOrganizationWithContext", reflect.TypeOf((*MockHealthAPI)(nil).EnableHealthServiceAccessForOrganizationWithContext), varargs...) +} diff --git a/pkg/mocks/mock_iam.go b/pkg/mocks/mock_iam.go new file mode 100644 index 0000000..6e6c6ae --- /dev/null +++ b/pkg/mocks/mock_iam.go @@ -0,0 +1,8026 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/iam/iamiface (interfaces: IAMAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + iam "github.com/aws/aws-sdk-go/service/iam" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockIAMAPI is a mock of IAMAPI interface +type MockIAMAPI struct { + ctrl *gomock.Controller + recorder *MockIAMAPIMockRecorder +} + +// MockIAMAPIMockRecorder is the mock recorder for MockIAMAPI +type MockIAMAPIMockRecorder struct { + mock *MockIAMAPI +} + +// NewMockIAMAPI creates a new mock instance +func NewMockIAMAPI(ctrl *gomock.Controller) *MockIAMAPI { + mock := &MockIAMAPI{ctrl: ctrl} + mock.recorder = &MockIAMAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockIAMAPI) EXPECT() *MockIAMAPIMockRecorder { + return m.recorder +} + +// AddClientIDToOpenIDConnectProvider mocks base method +func (m *MockIAMAPI) AddClientIDToOpenIDConnectProvider(arg0 *iam.AddClientIDToOpenIDConnectProviderInput) (*iam.AddClientIDToOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddClientIDToOpenIDConnectProvider", arg0) + ret0, _ := ret[0].(*iam.AddClientIDToOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddClientIDToOpenIDConnectProvider indicates an expected call of AddClientIDToOpenIDConnectProvider +func (mr *MockIAMAPIMockRecorder) AddClientIDToOpenIDConnectProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddClientIDToOpenIDConnectProvider", reflect.TypeOf((*MockIAMAPI)(nil).AddClientIDToOpenIDConnectProvider), arg0) +} + +// AddClientIDToOpenIDConnectProviderRequest mocks base method +func (m *MockIAMAPI) AddClientIDToOpenIDConnectProviderRequest(arg0 *iam.AddClientIDToOpenIDConnectProviderInput) (*request.Request, *iam.AddClientIDToOpenIDConnectProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddClientIDToOpenIDConnectProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.AddClientIDToOpenIDConnectProviderOutput) + return ret0, ret1 +} + +// AddClientIDToOpenIDConnectProviderRequest indicates an expected call of AddClientIDToOpenIDConnectProviderRequest +func (mr *MockIAMAPIMockRecorder) AddClientIDToOpenIDConnectProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddClientIDToOpenIDConnectProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).AddClientIDToOpenIDConnectProviderRequest), arg0) +} + +// AddClientIDToOpenIDConnectProviderWithContext mocks base method +func (m *MockIAMAPI) AddClientIDToOpenIDConnectProviderWithContext(arg0 context.Context, arg1 *iam.AddClientIDToOpenIDConnectProviderInput, arg2 ...request.Option) (*iam.AddClientIDToOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddClientIDToOpenIDConnectProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.AddClientIDToOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddClientIDToOpenIDConnectProviderWithContext indicates an expected call of AddClientIDToOpenIDConnectProviderWithContext +func (mr *MockIAMAPIMockRecorder) AddClientIDToOpenIDConnectProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddClientIDToOpenIDConnectProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).AddClientIDToOpenIDConnectProviderWithContext), varargs...) +} + +// AddRoleToInstanceProfile mocks base method +func (m *MockIAMAPI) AddRoleToInstanceProfile(arg0 *iam.AddRoleToInstanceProfileInput) (*iam.AddRoleToInstanceProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddRoleToInstanceProfile", arg0) + ret0, _ := ret[0].(*iam.AddRoleToInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddRoleToInstanceProfile indicates an expected call of AddRoleToInstanceProfile +func (mr *MockIAMAPIMockRecorder) AddRoleToInstanceProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToInstanceProfile", reflect.TypeOf((*MockIAMAPI)(nil).AddRoleToInstanceProfile), arg0) +} + +// AddRoleToInstanceProfileRequest mocks base method +func (m *MockIAMAPI) AddRoleToInstanceProfileRequest(arg0 *iam.AddRoleToInstanceProfileInput) (*request.Request, *iam.AddRoleToInstanceProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddRoleToInstanceProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.AddRoleToInstanceProfileOutput) + return ret0, ret1 +} + +// AddRoleToInstanceProfileRequest indicates an expected call of AddRoleToInstanceProfileRequest +func (mr *MockIAMAPIMockRecorder) AddRoleToInstanceProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToInstanceProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).AddRoleToInstanceProfileRequest), arg0) +} + +// AddRoleToInstanceProfileWithContext mocks base method +func (m *MockIAMAPI) AddRoleToInstanceProfileWithContext(arg0 context.Context, arg1 *iam.AddRoleToInstanceProfileInput, arg2 ...request.Option) (*iam.AddRoleToInstanceProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddRoleToInstanceProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.AddRoleToInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddRoleToInstanceProfileWithContext indicates an expected call of AddRoleToInstanceProfileWithContext +func (mr *MockIAMAPIMockRecorder) AddRoleToInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleToInstanceProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).AddRoleToInstanceProfileWithContext), varargs...) +} + +// AddUserToGroup mocks base method +func (m *MockIAMAPI) AddUserToGroup(arg0 *iam.AddUserToGroupInput) (*iam.AddUserToGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddUserToGroup", arg0) + ret0, _ := ret[0].(*iam.AddUserToGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddUserToGroup indicates an expected call of AddUserToGroup +func (mr *MockIAMAPIMockRecorder) AddUserToGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUserToGroup", reflect.TypeOf((*MockIAMAPI)(nil).AddUserToGroup), arg0) +} + +// AddUserToGroupRequest mocks base method +func (m *MockIAMAPI) AddUserToGroupRequest(arg0 *iam.AddUserToGroupInput) (*request.Request, *iam.AddUserToGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddUserToGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.AddUserToGroupOutput) + return ret0, ret1 +} + +// AddUserToGroupRequest indicates an expected call of AddUserToGroupRequest +func (mr *MockIAMAPIMockRecorder) AddUserToGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUserToGroupRequest", reflect.TypeOf((*MockIAMAPI)(nil).AddUserToGroupRequest), arg0) +} + +// AddUserToGroupWithContext mocks base method +func (m *MockIAMAPI) AddUserToGroupWithContext(arg0 context.Context, arg1 *iam.AddUserToGroupInput, arg2 ...request.Option) (*iam.AddUserToGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddUserToGroupWithContext", varargs...) + ret0, _ := ret[0].(*iam.AddUserToGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddUserToGroupWithContext indicates an expected call of AddUserToGroupWithContext +func (mr *MockIAMAPIMockRecorder) AddUserToGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUserToGroupWithContext", reflect.TypeOf((*MockIAMAPI)(nil).AddUserToGroupWithContext), varargs...) +} + +// AttachGroupPolicy mocks base method +func (m *MockIAMAPI) AttachGroupPolicy(arg0 *iam.AttachGroupPolicyInput) (*iam.AttachGroupPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachGroupPolicy", arg0) + ret0, _ := ret[0].(*iam.AttachGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachGroupPolicy indicates an expected call of AttachGroupPolicy +func (mr *MockIAMAPIMockRecorder) AttachGroupPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachGroupPolicy", reflect.TypeOf((*MockIAMAPI)(nil).AttachGroupPolicy), arg0) +} + +// AttachGroupPolicyRequest mocks base method +func (m *MockIAMAPI) AttachGroupPolicyRequest(arg0 *iam.AttachGroupPolicyInput) (*request.Request, *iam.AttachGroupPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachGroupPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.AttachGroupPolicyOutput) + return ret0, ret1 +} + +// AttachGroupPolicyRequest indicates an expected call of AttachGroupPolicyRequest +func (mr *MockIAMAPIMockRecorder) AttachGroupPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachGroupPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).AttachGroupPolicyRequest), arg0) +} + +// AttachGroupPolicyWithContext mocks base method +func (m *MockIAMAPI) AttachGroupPolicyWithContext(arg0 context.Context, arg1 *iam.AttachGroupPolicyInput, arg2 ...request.Option) (*iam.AttachGroupPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachGroupPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.AttachGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachGroupPolicyWithContext indicates an expected call of AttachGroupPolicyWithContext +func (mr *MockIAMAPIMockRecorder) AttachGroupPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachGroupPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).AttachGroupPolicyWithContext), varargs...) +} + +// AttachRolePolicy mocks base method +func (m *MockIAMAPI) AttachRolePolicy(arg0 *iam.AttachRolePolicyInput) (*iam.AttachRolePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachRolePolicy", arg0) + ret0, _ := ret[0].(*iam.AttachRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachRolePolicy indicates an expected call of AttachRolePolicy +func (mr *MockIAMAPIMockRecorder) AttachRolePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachRolePolicy", reflect.TypeOf((*MockIAMAPI)(nil).AttachRolePolicy), arg0) +} + +// AttachRolePolicyRequest mocks base method +func (m *MockIAMAPI) AttachRolePolicyRequest(arg0 *iam.AttachRolePolicyInput) (*request.Request, *iam.AttachRolePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachRolePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.AttachRolePolicyOutput) + return ret0, ret1 +} + +// AttachRolePolicyRequest indicates an expected call of AttachRolePolicyRequest +func (mr *MockIAMAPIMockRecorder) AttachRolePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachRolePolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).AttachRolePolicyRequest), arg0) +} + +// AttachRolePolicyWithContext mocks base method +func (m *MockIAMAPI) AttachRolePolicyWithContext(arg0 context.Context, arg1 *iam.AttachRolePolicyInput, arg2 ...request.Option) (*iam.AttachRolePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachRolePolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.AttachRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachRolePolicyWithContext indicates an expected call of AttachRolePolicyWithContext +func (mr *MockIAMAPIMockRecorder) AttachRolePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachRolePolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).AttachRolePolicyWithContext), varargs...) +} + +// AttachUserPolicy mocks base method +func (m *MockIAMAPI) AttachUserPolicy(arg0 *iam.AttachUserPolicyInput) (*iam.AttachUserPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachUserPolicy", arg0) + ret0, _ := ret[0].(*iam.AttachUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachUserPolicy indicates an expected call of AttachUserPolicy +func (mr *MockIAMAPIMockRecorder) AttachUserPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachUserPolicy", reflect.TypeOf((*MockIAMAPI)(nil).AttachUserPolicy), arg0) +} + +// AttachUserPolicyRequest mocks base method +func (m *MockIAMAPI) AttachUserPolicyRequest(arg0 *iam.AttachUserPolicyInput) (*request.Request, *iam.AttachUserPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachUserPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.AttachUserPolicyOutput) + return ret0, ret1 +} + +// AttachUserPolicyRequest indicates an expected call of AttachUserPolicyRequest +func (mr *MockIAMAPIMockRecorder) AttachUserPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachUserPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).AttachUserPolicyRequest), arg0) +} + +// AttachUserPolicyWithContext mocks base method +func (m *MockIAMAPI) AttachUserPolicyWithContext(arg0 context.Context, arg1 *iam.AttachUserPolicyInput, arg2 ...request.Option) (*iam.AttachUserPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachUserPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.AttachUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachUserPolicyWithContext indicates an expected call of AttachUserPolicyWithContext +func (mr *MockIAMAPIMockRecorder) AttachUserPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachUserPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).AttachUserPolicyWithContext), varargs...) +} + +// ChangePassword mocks base method +func (m *MockIAMAPI) ChangePassword(arg0 *iam.ChangePasswordInput) (*iam.ChangePasswordOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangePassword", arg0) + ret0, _ := ret[0].(*iam.ChangePasswordOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangePassword indicates an expected call of ChangePassword +func (mr *MockIAMAPIMockRecorder) ChangePassword(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePassword", reflect.TypeOf((*MockIAMAPI)(nil).ChangePassword), arg0) +} + +// ChangePasswordRequest mocks base method +func (m *MockIAMAPI) ChangePasswordRequest(arg0 *iam.ChangePasswordInput) (*request.Request, *iam.ChangePasswordOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangePasswordRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ChangePasswordOutput) + return ret0, ret1 +} + +// ChangePasswordRequest indicates an expected call of ChangePasswordRequest +func (mr *MockIAMAPIMockRecorder) ChangePasswordRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePasswordRequest", reflect.TypeOf((*MockIAMAPI)(nil).ChangePasswordRequest), arg0) +} + +// ChangePasswordWithContext mocks base method +func (m *MockIAMAPI) ChangePasswordWithContext(arg0 context.Context, arg1 *iam.ChangePasswordInput, arg2 ...request.Option) (*iam.ChangePasswordOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangePasswordWithContext", varargs...) + ret0, _ := ret[0].(*iam.ChangePasswordOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangePasswordWithContext indicates an expected call of ChangePasswordWithContext +func (mr *MockIAMAPIMockRecorder) ChangePasswordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePasswordWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ChangePasswordWithContext), varargs...) +} + +// CreateAccessKey mocks base method +func (m *MockIAMAPI) CreateAccessKey(arg0 *iam.CreateAccessKeyInput) (*iam.CreateAccessKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAccessKey", arg0) + ret0, _ := ret[0].(*iam.CreateAccessKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAccessKey indicates an expected call of CreateAccessKey +func (mr *MockIAMAPIMockRecorder) CreateAccessKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccessKey", reflect.TypeOf((*MockIAMAPI)(nil).CreateAccessKey), arg0) +} + +// CreateAccessKeyRequest mocks base method +func (m *MockIAMAPI) CreateAccessKeyRequest(arg0 *iam.CreateAccessKeyInput) (*request.Request, *iam.CreateAccessKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAccessKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateAccessKeyOutput) + return ret0, ret1 +} + +// CreateAccessKeyRequest indicates an expected call of CreateAccessKeyRequest +func (mr *MockIAMAPIMockRecorder) CreateAccessKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccessKeyRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateAccessKeyRequest), arg0) +} + +// CreateAccessKeyWithContext mocks base method +func (m *MockIAMAPI) CreateAccessKeyWithContext(arg0 context.Context, arg1 *iam.CreateAccessKeyInput, arg2 ...request.Option) (*iam.CreateAccessKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateAccessKeyWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateAccessKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAccessKeyWithContext indicates an expected call of CreateAccessKeyWithContext +func (mr *MockIAMAPIMockRecorder) CreateAccessKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccessKeyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateAccessKeyWithContext), varargs...) +} + +// CreateAccountAlias mocks base method +func (m *MockIAMAPI) CreateAccountAlias(arg0 *iam.CreateAccountAliasInput) (*iam.CreateAccountAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAccountAlias", arg0) + ret0, _ := ret[0].(*iam.CreateAccountAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAccountAlias indicates an expected call of CreateAccountAlias +func (mr *MockIAMAPIMockRecorder) CreateAccountAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccountAlias", reflect.TypeOf((*MockIAMAPI)(nil).CreateAccountAlias), arg0) +} + +// CreateAccountAliasRequest mocks base method +func (m *MockIAMAPI) CreateAccountAliasRequest(arg0 *iam.CreateAccountAliasInput) (*request.Request, *iam.CreateAccountAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAccountAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateAccountAliasOutput) + return ret0, ret1 +} + +// CreateAccountAliasRequest indicates an expected call of CreateAccountAliasRequest +func (mr *MockIAMAPIMockRecorder) CreateAccountAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccountAliasRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateAccountAliasRequest), arg0) +} + +// CreateAccountAliasWithContext mocks base method +func (m *MockIAMAPI) CreateAccountAliasWithContext(arg0 context.Context, arg1 *iam.CreateAccountAliasInput, arg2 ...request.Option) (*iam.CreateAccountAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateAccountAliasWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateAccountAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAccountAliasWithContext indicates an expected call of CreateAccountAliasWithContext +func (mr *MockIAMAPIMockRecorder) CreateAccountAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccountAliasWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateAccountAliasWithContext), varargs...) +} + +// CreateGroup mocks base method +func (m *MockIAMAPI) CreateGroup(arg0 *iam.CreateGroupInput) (*iam.CreateGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGroup", arg0) + ret0, _ := ret[0].(*iam.CreateGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGroup indicates an expected call of CreateGroup +func (mr *MockIAMAPIMockRecorder) CreateGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroup", reflect.TypeOf((*MockIAMAPI)(nil).CreateGroup), arg0) +} + +// CreateGroupRequest mocks base method +func (m *MockIAMAPI) CreateGroupRequest(arg0 *iam.CreateGroupInput) (*request.Request, *iam.CreateGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateGroupOutput) + return ret0, ret1 +} + +// CreateGroupRequest indicates an expected call of CreateGroupRequest +func (mr *MockIAMAPIMockRecorder) CreateGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroupRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateGroupRequest), arg0) +} + +// CreateGroupWithContext mocks base method +func (m *MockIAMAPI) CreateGroupWithContext(arg0 context.Context, arg1 *iam.CreateGroupInput, arg2 ...request.Option) (*iam.CreateGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateGroupWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGroupWithContext indicates an expected call of CreateGroupWithContext +func (mr *MockIAMAPIMockRecorder) CreateGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroupWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateGroupWithContext), varargs...) +} + +// CreateInstanceProfile mocks base method +func (m *MockIAMAPI) CreateInstanceProfile(arg0 *iam.CreateInstanceProfileInput) (*iam.CreateInstanceProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInstanceProfile", arg0) + ret0, _ := ret[0].(*iam.CreateInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateInstanceProfile indicates an expected call of CreateInstanceProfile +func (mr *MockIAMAPIMockRecorder) CreateInstanceProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceProfile", reflect.TypeOf((*MockIAMAPI)(nil).CreateInstanceProfile), arg0) +} + +// CreateInstanceProfileRequest mocks base method +func (m *MockIAMAPI) CreateInstanceProfileRequest(arg0 *iam.CreateInstanceProfileInput) (*request.Request, *iam.CreateInstanceProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInstanceProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateInstanceProfileOutput) + return ret0, ret1 +} + +// CreateInstanceProfileRequest indicates an expected call of CreateInstanceProfileRequest +func (mr *MockIAMAPIMockRecorder) CreateInstanceProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateInstanceProfileRequest), arg0) +} + +// CreateInstanceProfileWithContext mocks base method +func (m *MockIAMAPI) CreateInstanceProfileWithContext(arg0 context.Context, arg1 *iam.CreateInstanceProfileInput, arg2 ...request.Option) (*iam.CreateInstanceProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateInstanceProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateInstanceProfileWithContext indicates an expected call of CreateInstanceProfileWithContext +func (mr *MockIAMAPIMockRecorder) CreateInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateInstanceProfileWithContext), varargs...) +} + +// CreateLoginProfile mocks base method +func (m *MockIAMAPI) CreateLoginProfile(arg0 *iam.CreateLoginProfileInput) (*iam.CreateLoginProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLoginProfile", arg0) + ret0, _ := ret[0].(*iam.CreateLoginProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLoginProfile indicates an expected call of CreateLoginProfile +func (mr *MockIAMAPIMockRecorder) CreateLoginProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoginProfile", reflect.TypeOf((*MockIAMAPI)(nil).CreateLoginProfile), arg0) +} + +// CreateLoginProfileRequest mocks base method +func (m *MockIAMAPI) CreateLoginProfileRequest(arg0 *iam.CreateLoginProfileInput) (*request.Request, *iam.CreateLoginProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLoginProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateLoginProfileOutput) + return ret0, ret1 +} + +// CreateLoginProfileRequest indicates an expected call of CreateLoginProfileRequest +func (mr *MockIAMAPIMockRecorder) CreateLoginProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoginProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateLoginProfileRequest), arg0) +} + +// CreateLoginProfileWithContext mocks base method +func (m *MockIAMAPI) CreateLoginProfileWithContext(arg0 context.Context, arg1 *iam.CreateLoginProfileInput, arg2 ...request.Option) (*iam.CreateLoginProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateLoginProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateLoginProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLoginProfileWithContext indicates an expected call of CreateLoginProfileWithContext +func (mr *MockIAMAPIMockRecorder) CreateLoginProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoginProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateLoginProfileWithContext), varargs...) +} + +// CreateOpenIDConnectProvider mocks base method +func (m *MockIAMAPI) CreateOpenIDConnectProvider(arg0 *iam.CreateOpenIDConnectProviderInput) (*iam.CreateOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOpenIDConnectProvider", arg0) + ret0, _ := ret[0].(*iam.CreateOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOpenIDConnectProvider indicates an expected call of CreateOpenIDConnectProvider +func (mr *MockIAMAPIMockRecorder) CreateOpenIDConnectProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpenIDConnectProvider", reflect.TypeOf((*MockIAMAPI)(nil).CreateOpenIDConnectProvider), arg0) +} + +// CreateOpenIDConnectProviderRequest mocks base method +func (m *MockIAMAPI) CreateOpenIDConnectProviderRequest(arg0 *iam.CreateOpenIDConnectProviderInput) (*request.Request, *iam.CreateOpenIDConnectProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOpenIDConnectProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateOpenIDConnectProviderOutput) + return ret0, ret1 +} + +// CreateOpenIDConnectProviderRequest indicates an expected call of CreateOpenIDConnectProviderRequest +func (mr *MockIAMAPIMockRecorder) CreateOpenIDConnectProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpenIDConnectProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateOpenIDConnectProviderRequest), arg0) +} + +// CreateOpenIDConnectProviderWithContext mocks base method +func (m *MockIAMAPI) CreateOpenIDConnectProviderWithContext(arg0 context.Context, arg1 *iam.CreateOpenIDConnectProviderInput, arg2 ...request.Option) (*iam.CreateOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateOpenIDConnectProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOpenIDConnectProviderWithContext indicates an expected call of CreateOpenIDConnectProviderWithContext +func (mr *MockIAMAPIMockRecorder) CreateOpenIDConnectProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpenIDConnectProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateOpenIDConnectProviderWithContext), varargs...) +} + +// CreatePolicy mocks base method +func (m *MockIAMAPI) CreatePolicy(arg0 *iam.CreatePolicyInput) (*iam.CreatePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePolicy", arg0) + ret0, _ := ret[0].(*iam.CreatePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePolicy indicates an expected call of CreatePolicy +func (mr *MockIAMAPIMockRecorder) CreatePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePolicy", reflect.TypeOf((*MockIAMAPI)(nil).CreatePolicy), arg0) +} + +// CreatePolicyRequest mocks base method +func (m *MockIAMAPI) CreatePolicyRequest(arg0 *iam.CreatePolicyInput) (*request.Request, *iam.CreatePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreatePolicyOutput) + return ret0, ret1 +} + +// CreatePolicyRequest indicates an expected call of CreatePolicyRequest +func (mr *MockIAMAPIMockRecorder) CreatePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreatePolicyRequest), arg0) +} + +// CreatePolicyVersion mocks base method +func (m *MockIAMAPI) CreatePolicyVersion(arg0 *iam.CreatePolicyVersionInput) (*iam.CreatePolicyVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePolicyVersion", arg0) + ret0, _ := ret[0].(*iam.CreatePolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePolicyVersion indicates an expected call of CreatePolicyVersion +func (mr *MockIAMAPIMockRecorder) CreatePolicyVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePolicyVersion", reflect.TypeOf((*MockIAMAPI)(nil).CreatePolicyVersion), arg0) +} + +// CreatePolicyVersionRequest mocks base method +func (m *MockIAMAPI) CreatePolicyVersionRequest(arg0 *iam.CreatePolicyVersionInput) (*request.Request, *iam.CreatePolicyVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePolicyVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreatePolicyVersionOutput) + return ret0, ret1 +} + +// CreatePolicyVersionRequest indicates an expected call of CreatePolicyVersionRequest +func (mr *MockIAMAPIMockRecorder) CreatePolicyVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePolicyVersionRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreatePolicyVersionRequest), arg0) +} + +// CreatePolicyVersionWithContext mocks base method +func (m *MockIAMAPI) CreatePolicyVersionWithContext(arg0 context.Context, arg1 *iam.CreatePolicyVersionInput, arg2 ...request.Option) (*iam.CreatePolicyVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePolicyVersionWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreatePolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePolicyVersionWithContext indicates an expected call of CreatePolicyVersionWithContext +func (mr *MockIAMAPIMockRecorder) CreatePolicyVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePolicyVersionWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreatePolicyVersionWithContext), varargs...) +} + +// CreatePolicyWithContext mocks base method +func (m *MockIAMAPI) CreatePolicyWithContext(arg0 context.Context, arg1 *iam.CreatePolicyInput, arg2 ...request.Option) (*iam.CreatePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreatePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePolicyWithContext indicates an expected call of CreatePolicyWithContext +func (mr *MockIAMAPIMockRecorder) CreatePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreatePolicyWithContext), varargs...) +} + +// CreateRole mocks base method +func (m *MockIAMAPI) CreateRole(arg0 *iam.CreateRoleInput) (*iam.CreateRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRole", arg0) + ret0, _ := ret[0].(*iam.CreateRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRole indicates an expected call of CreateRole +func (mr *MockIAMAPIMockRecorder) CreateRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRole", reflect.TypeOf((*MockIAMAPI)(nil).CreateRole), arg0) +} + +// CreateRoleRequest mocks base method +func (m *MockIAMAPI) CreateRoleRequest(arg0 *iam.CreateRoleInput) (*request.Request, *iam.CreateRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateRoleOutput) + return ret0, ret1 +} + +// CreateRoleRequest indicates an expected call of CreateRoleRequest +func (mr *MockIAMAPIMockRecorder) CreateRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateRoleRequest), arg0) +} + +// CreateRoleWithContext mocks base method +func (m *MockIAMAPI) CreateRoleWithContext(arg0 context.Context, arg1 *iam.CreateRoleInput, arg2 ...request.Option) (*iam.CreateRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRoleWithContext indicates an expected call of CreateRoleWithContext +func (mr *MockIAMAPIMockRecorder) CreateRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateRoleWithContext), varargs...) +} + +// CreateSAMLProvider mocks base method +func (m *MockIAMAPI) CreateSAMLProvider(arg0 *iam.CreateSAMLProviderInput) (*iam.CreateSAMLProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSAMLProvider", arg0) + ret0, _ := ret[0].(*iam.CreateSAMLProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSAMLProvider indicates an expected call of CreateSAMLProvider +func (mr *MockIAMAPIMockRecorder) CreateSAMLProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSAMLProvider", reflect.TypeOf((*MockIAMAPI)(nil).CreateSAMLProvider), arg0) +} + +// CreateSAMLProviderRequest mocks base method +func (m *MockIAMAPI) CreateSAMLProviderRequest(arg0 *iam.CreateSAMLProviderInput) (*request.Request, *iam.CreateSAMLProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSAMLProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateSAMLProviderOutput) + return ret0, ret1 +} + +// CreateSAMLProviderRequest indicates an expected call of CreateSAMLProviderRequest +func (mr *MockIAMAPIMockRecorder) CreateSAMLProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSAMLProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateSAMLProviderRequest), arg0) +} + +// CreateSAMLProviderWithContext mocks base method +func (m *MockIAMAPI) CreateSAMLProviderWithContext(arg0 context.Context, arg1 *iam.CreateSAMLProviderInput, arg2 ...request.Option) (*iam.CreateSAMLProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateSAMLProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateSAMLProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSAMLProviderWithContext indicates an expected call of CreateSAMLProviderWithContext +func (mr *MockIAMAPIMockRecorder) CreateSAMLProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSAMLProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateSAMLProviderWithContext), varargs...) +} + +// CreateServiceLinkedRole mocks base method +func (m *MockIAMAPI) CreateServiceLinkedRole(arg0 *iam.CreateServiceLinkedRoleInput) (*iam.CreateServiceLinkedRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateServiceLinkedRole", arg0) + ret0, _ := ret[0].(*iam.CreateServiceLinkedRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateServiceLinkedRole indicates an expected call of CreateServiceLinkedRole +func (mr *MockIAMAPIMockRecorder) CreateServiceLinkedRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceLinkedRole", reflect.TypeOf((*MockIAMAPI)(nil).CreateServiceLinkedRole), arg0) +} + +// CreateServiceLinkedRoleRequest mocks base method +func (m *MockIAMAPI) CreateServiceLinkedRoleRequest(arg0 *iam.CreateServiceLinkedRoleInput) (*request.Request, *iam.CreateServiceLinkedRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateServiceLinkedRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateServiceLinkedRoleOutput) + return ret0, ret1 +} + +// CreateServiceLinkedRoleRequest indicates an expected call of CreateServiceLinkedRoleRequest +func (mr *MockIAMAPIMockRecorder) CreateServiceLinkedRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceLinkedRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateServiceLinkedRoleRequest), arg0) +} + +// CreateServiceLinkedRoleWithContext mocks base method +func (m *MockIAMAPI) CreateServiceLinkedRoleWithContext(arg0 context.Context, arg1 *iam.CreateServiceLinkedRoleInput, arg2 ...request.Option) (*iam.CreateServiceLinkedRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateServiceLinkedRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateServiceLinkedRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateServiceLinkedRoleWithContext indicates an expected call of CreateServiceLinkedRoleWithContext +func (mr *MockIAMAPIMockRecorder) CreateServiceLinkedRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceLinkedRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateServiceLinkedRoleWithContext), varargs...) +} + +// CreateServiceSpecificCredential mocks base method +func (m *MockIAMAPI) CreateServiceSpecificCredential(arg0 *iam.CreateServiceSpecificCredentialInput) (*iam.CreateServiceSpecificCredentialOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateServiceSpecificCredential", arg0) + ret0, _ := ret[0].(*iam.CreateServiceSpecificCredentialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateServiceSpecificCredential indicates an expected call of CreateServiceSpecificCredential +func (mr *MockIAMAPIMockRecorder) CreateServiceSpecificCredential(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceSpecificCredential", reflect.TypeOf((*MockIAMAPI)(nil).CreateServiceSpecificCredential), arg0) +} + +// CreateServiceSpecificCredentialRequest mocks base method +func (m *MockIAMAPI) CreateServiceSpecificCredentialRequest(arg0 *iam.CreateServiceSpecificCredentialInput) (*request.Request, *iam.CreateServiceSpecificCredentialOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateServiceSpecificCredentialRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateServiceSpecificCredentialOutput) + return ret0, ret1 +} + +// CreateServiceSpecificCredentialRequest indicates an expected call of CreateServiceSpecificCredentialRequest +func (mr *MockIAMAPIMockRecorder) CreateServiceSpecificCredentialRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceSpecificCredentialRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateServiceSpecificCredentialRequest), arg0) +} + +// CreateServiceSpecificCredentialWithContext mocks base method +func (m *MockIAMAPI) CreateServiceSpecificCredentialWithContext(arg0 context.Context, arg1 *iam.CreateServiceSpecificCredentialInput, arg2 ...request.Option) (*iam.CreateServiceSpecificCredentialOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateServiceSpecificCredentialWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateServiceSpecificCredentialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateServiceSpecificCredentialWithContext indicates an expected call of CreateServiceSpecificCredentialWithContext +func (mr *MockIAMAPIMockRecorder) CreateServiceSpecificCredentialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceSpecificCredentialWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateServiceSpecificCredentialWithContext), varargs...) +} + +// CreateUser mocks base method +func (m *MockIAMAPI) CreateUser(arg0 *iam.CreateUserInput) (*iam.CreateUserOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateUser", arg0) + ret0, _ := ret[0].(*iam.CreateUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateUser indicates an expected call of CreateUser +func (mr *MockIAMAPIMockRecorder) CreateUser(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUser", reflect.TypeOf((*MockIAMAPI)(nil).CreateUser), arg0) +} + +// CreateUserRequest mocks base method +func (m *MockIAMAPI) CreateUserRequest(arg0 *iam.CreateUserInput) (*request.Request, *iam.CreateUserOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateUserRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateUserOutput) + return ret0, ret1 +} + +// CreateUserRequest indicates an expected call of CreateUserRequest +func (mr *MockIAMAPIMockRecorder) CreateUserRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateUserRequest), arg0) +} + +// CreateUserWithContext mocks base method +func (m *MockIAMAPI) CreateUserWithContext(arg0 context.Context, arg1 *iam.CreateUserInput, arg2 ...request.Option) (*iam.CreateUserOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateUserWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateUserWithContext indicates an expected call of CreateUserWithContext +func (mr *MockIAMAPIMockRecorder) CreateUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateUserWithContext), varargs...) +} + +// CreateVirtualMFADevice mocks base method +func (m *MockIAMAPI) CreateVirtualMFADevice(arg0 *iam.CreateVirtualMFADeviceInput) (*iam.CreateVirtualMFADeviceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVirtualMFADevice", arg0) + ret0, _ := ret[0].(*iam.CreateVirtualMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVirtualMFADevice indicates an expected call of CreateVirtualMFADevice +func (mr *MockIAMAPIMockRecorder) CreateVirtualMFADevice(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVirtualMFADevice", reflect.TypeOf((*MockIAMAPI)(nil).CreateVirtualMFADevice), arg0) +} + +// CreateVirtualMFADeviceRequest mocks base method +func (m *MockIAMAPI) CreateVirtualMFADeviceRequest(arg0 *iam.CreateVirtualMFADeviceInput) (*request.Request, *iam.CreateVirtualMFADeviceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateVirtualMFADeviceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.CreateVirtualMFADeviceOutput) + return ret0, ret1 +} + +// CreateVirtualMFADeviceRequest indicates an expected call of CreateVirtualMFADeviceRequest +func (mr *MockIAMAPIMockRecorder) CreateVirtualMFADeviceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVirtualMFADeviceRequest", reflect.TypeOf((*MockIAMAPI)(nil).CreateVirtualMFADeviceRequest), arg0) +} + +// CreateVirtualMFADeviceWithContext mocks base method +func (m *MockIAMAPI) CreateVirtualMFADeviceWithContext(arg0 context.Context, arg1 *iam.CreateVirtualMFADeviceInput, arg2 ...request.Option) (*iam.CreateVirtualMFADeviceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateVirtualMFADeviceWithContext", varargs...) + ret0, _ := ret[0].(*iam.CreateVirtualMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateVirtualMFADeviceWithContext indicates an expected call of CreateVirtualMFADeviceWithContext +func (mr *MockIAMAPIMockRecorder) CreateVirtualMFADeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVirtualMFADeviceWithContext", reflect.TypeOf((*MockIAMAPI)(nil).CreateVirtualMFADeviceWithContext), varargs...) +} + +// DeactivateMFADevice mocks base method +func (m *MockIAMAPI) DeactivateMFADevice(arg0 *iam.DeactivateMFADeviceInput) (*iam.DeactivateMFADeviceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeactivateMFADevice", arg0) + ret0, _ := ret[0].(*iam.DeactivateMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateMFADevice indicates an expected call of DeactivateMFADevice +func (mr *MockIAMAPIMockRecorder) DeactivateMFADevice(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateMFADevice", reflect.TypeOf((*MockIAMAPI)(nil).DeactivateMFADevice), arg0) +} + +// DeactivateMFADeviceRequest mocks base method +func (m *MockIAMAPI) DeactivateMFADeviceRequest(arg0 *iam.DeactivateMFADeviceInput) (*request.Request, *iam.DeactivateMFADeviceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeactivateMFADeviceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeactivateMFADeviceOutput) + return ret0, ret1 +} + +// DeactivateMFADeviceRequest indicates an expected call of DeactivateMFADeviceRequest +func (mr *MockIAMAPIMockRecorder) DeactivateMFADeviceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateMFADeviceRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeactivateMFADeviceRequest), arg0) +} + +// DeactivateMFADeviceWithContext mocks base method +func (m *MockIAMAPI) DeactivateMFADeviceWithContext(arg0 context.Context, arg1 *iam.DeactivateMFADeviceInput, arg2 ...request.Option) (*iam.DeactivateMFADeviceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateMFADeviceWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeactivateMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateMFADeviceWithContext indicates an expected call of DeactivateMFADeviceWithContext +func (mr *MockIAMAPIMockRecorder) DeactivateMFADeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateMFADeviceWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeactivateMFADeviceWithContext), varargs...) +} + +// DeleteAccessKey mocks base method +func (m *MockIAMAPI) DeleteAccessKey(arg0 *iam.DeleteAccessKeyInput) (*iam.DeleteAccessKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAccessKey", arg0) + ret0, _ := ret[0].(*iam.DeleteAccessKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAccessKey indicates an expected call of DeleteAccessKey +func (mr *MockIAMAPIMockRecorder) DeleteAccessKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccessKey", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccessKey), arg0) +} + +// DeleteAccessKeyRequest mocks base method +func (m *MockIAMAPI) DeleteAccessKeyRequest(arg0 *iam.DeleteAccessKeyInput) (*request.Request, *iam.DeleteAccessKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAccessKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteAccessKeyOutput) + return ret0, ret1 +} + +// DeleteAccessKeyRequest indicates an expected call of DeleteAccessKeyRequest +func (mr *MockIAMAPIMockRecorder) DeleteAccessKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccessKeyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccessKeyRequest), arg0) +} + +// DeleteAccessKeyWithContext mocks base method +func (m *MockIAMAPI) DeleteAccessKeyWithContext(arg0 context.Context, arg1 *iam.DeleteAccessKeyInput, arg2 ...request.Option) (*iam.DeleteAccessKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAccessKeyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteAccessKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAccessKeyWithContext indicates an expected call of DeleteAccessKeyWithContext +func (mr *MockIAMAPIMockRecorder) DeleteAccessKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccessKeyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccessKeyWithContext), varargs...) +} + +// DeleteAccountAlias mocks base method +func (m *MockIAMAPI) DeleteAccountAlias(arg0 *iam.DeleteAccountAliasInput) (*iam.DeleteAccountAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAccountAlias", arg0) + ret0, _ := ret[0].(*iam.DeleteAccountAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAccountAlias indicates an expected call of DeleteAccountAlias +func (mr *MockIAMAPIMockRecorder) DeleteAccountAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountAlias", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccountAlias), arg0) +} + +// DeleteAccountAliasRequest mocks base method +func (m *MockIAMAPI) DeleteAccountAliasRequest(arg0 *iam.DeleteAccountAliasInput) (*request.Request, *iam.DeleteAccountAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAccountAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteAccountAliasOutput) + return ret0, ret1 +} + +// DeleteAccountAliasRequest indicates an expected call of DeleteAccountAliasRequest +func (mr *MockIAMAPIMockRecorder) DeleteAccountAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountAliasRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccountAliasRequest), arg0) +} + +// DeleteAccountAliasWithContext mocks base method +func (m *MockIAMAPI) DeleteAccountAliasWithContext(arg0 context.Context, arg1 *iam.DeleteAccountAliasInput, arg2 ...request.Option) (*iam.DeleteAccountAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAccountAliasWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteAccountAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAccountAliasWithContext indicates an expected call of DeleteAccountAliasWithContext +func (mr *MockIAMAPIMockRecorder) DeleteAccountAliasWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountAliasWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccountAliasWithContext), varargs...) +} + +// DeleteAccountPasswordPolicy mocks base method +func (m *MockIAMAPI) DeleteAccountPasswordPolicy(arg0 *iam.DeleteAccountPasswordPolicyInput) (*iam.DeleteAccountPasswordPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAccountPasswordPolicy", arg0) + ret0, _ := ret[0].(*iam.DeleteAccountPasswordPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAccountPasswordPolicy indicates an expected call of DeleteAccountPasswordPolicy +func (mr *MockIAMAPIMockRecorder) DeleteAccountPasswordPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountPasswordPolicy", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccountPasswordPolicy), arg0) +} + +// DeleteAccountPasswordPolicyRequest mocks base method +func (m *MockIAMAPI) DeleteAccountPasswordPolicyRequest(arg0 *iam.DeleteAccountPasswordPolicyInput) (*request.Request, *iam.DeleteAccountPasswordPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAccountPasswordPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteAccountPasswordPolicyOutput) + return ret0, ret1 +} + +// DeleteAccountPasswordPolicyRequest indicates an expected call of DeleteAccountPasswordPolicyRequest +func (mr *MockIAMAPIMockRecorder) DeleteAccountPasswordPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountPasswordPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccountPasswordPolicyRequest), arg0) +} + +// DeleteAccountPasswordPolicyWithContext mocks base method +func (m *MockIAMAPI) DeleteAccountPasswordPolicyWithContext(arg0 context.Context, arg1 *iam.DeleteAccountPasswordPolicyInput, arg2 ...request.Option) (*iam.DeleteAccountPasswordPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAccountPasswordPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteAccountPasswordPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAccountPasswordPolicyWithContext indicates an expected call of DeleteAccountPasswordPolicyWithContext +func (mr *MockIAMAPIMockRecorder) DeleteAccountPasswordPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountPasswordPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteAccountPasswordPolicyWithContext), varargs...) +} + +// DeleteGroup mocks base method +func (m *MockIAMAPI) DeleteGroup(arg0 *iam.DeleteGroupInput) (*iam.DeleteGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGroup", arg0) + ret0, _ := ret[0].(*iam.DeleteGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGroup indicates an expected call of DeleteGroup +func (mr *MockIAMAPIMockRecorder) DeleteGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroup", reflect.TypeOf((*MockIAMAPI)(nil).DeleteGroup), arg0) +} + +// DeleteGroupPolicy mocks base method +func (m *MockIAMAPI) DeleteGroupPolicy(arg0 *iam.DeleteGroupPolicyInput) (*iam.DeleteGroupPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGroupPolicy", arg0) + ret0, _ := ret[0].(*iam.DeleteGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGroupPolicy indicates an expected call of DeleteGroupPolicy +func (mr *MockIAMAPIMockRecorder) DeleteGroupPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupPolicy", reflect.TypeOf((*MockIAMAPI)(nil).DeleteGroupPolicy), arg0) +} + +// DeleteGroupPolicyRequest mocks base method +func (m *MockIAMAPI) DeleteGroupPolicyRequest(arg0 *iam.DeleteGroupPolicyInput) (*request.Request, *iam.DeleteGroupPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGroupPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteGroupPolicyOutput) + return ret0, ret1 +} + +// DeleteGroupPolicyRequest indicates an expected call of DeleteGroupPolicyRequest +func (mr *MockIAMAPIMockRecorder) DeleteGroupPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteGroupPolicyRequest), arg0) +} + +// DeleteGroupPolicyWithContext mocks base method +func (m *MockIAMAPI) DeleteGroupPolicyWithContext(arg0 context.Context, arg1 *iam.DeleteGroupPolicyInput, arg2 ...request.Option) (*iam.DeleteGroupPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteGroupPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGroupPolicyWithContext indicates an expected call of DeleteGroupPolicyWithContext +func (mr *MockIAMAPIMockRecorder) DeleteGroupPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteGroupPolicyWithContext), varargs...) +} + +// DeleteGroupRequest mocks base method +func (m *MockIAMAPI) DeleteGroupRequest(arg0 *iam.DeleteGroupInput) (*request.Request, *iam.DeleteGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteGroupOutput) + return ret0, ret1 +} + +// DeleteGroupRequest indicates an expected call of DeleteGroupRequest +func (mr *MockIAMAPIMockRecorder) DeleteGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteGroupRequest), arg0) +} + +// DeleteGroupWithContext mocks base method +func (m *MockIAMAPI) DeleteGroupWithContext(arg0 context.Context, arg1 *iam.DeleteGroupInput, arg2 ...request.Option) (*iam.DeleteGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteGroupWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteGroupWithContext indicates an expected call of DeleteGroupWithContext +func (mr *MockIAMAPIMockRecorder) DeleteGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteGroupWithContext), varargs...) +} + +// DeleteInstanceProfile mocks base method +func (m *MockIAMAPI) DeleteInstanceProfile(arg0 *iam.DeleteInstanceProfileInput) (*iam.DeleteInstanceProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteInstanceProfile", arg0) + ret0, _ := ret[0].(*iam.DeleteInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteInstanceProfile indicates an expected call of DeleteInstanceProfile +func (mr *MockIAMAPIMockRecorder) DeleteInstanceProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceProfile", reflect.TypeOf((*MockIAMAPI)(nil).DeleteInstanceProfile), arg0) +} + +// DeleteInstanceProfileRequest mocks base method +func (m *MockIAMAPI) DeleteInstanceProfileRequest(arg0 *iam.DeleteInstanceProfileInput) (*request.Request, *iam.DeleteInstanceProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteInstanceProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteInstanceProfileOutput) + return ret0, ret1 +} + +// DeleteInstanceProfileRequest indicates an expected call of DeleteInstanceProfileRequest +func (mr *MockIAMAPIMockRecorder) DeleteInstanceProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteInstanceProfileRequest), arg0) +} + +// DeleteInstanceProfileWithContext mocks base method +func (m *MockIAMAPI) DeleteInstanceProfileWithContext(arg0 context.Context, arg1 *iam.DeleteInstanceProfileInput, arg2 ...request.Option) (*iam.DeleteInstanceProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteInstanceProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteInstanceProfileWithContext indicates an expected call of DeleteInstanceProfileWithContext +func (mr *MockIAMAPIMockRecorder) DeleteInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteInstanceProfileWithContext), varargs...) +} + +// DeleteLoginProfile mocks base method +func (m *MockIAMAPI) DeleteLoginProfile(arg0 *iam.DeleteLoginProfileInput) (*iam.DeleteLoginProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLoginProfile", arg0) + ret0, _ := ret[0].(*iam.DeleteLoginProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLoginProfile indicates an expected call of DeleteLoginProfile +func (mr *MockIAMAPIMockRecorder) DeleteLoginProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoginProfile", reflect.TypeOf((*MockIAMAPI)(nil).DeleteLoginProfile), arg0) +} + +// DeleteLoginProfileRequest mocks base method +func (m *MockIAMAPI) DeleteLoginProfileRequest(arg0 *iam.DeleteLoginProfileInput) (*request.Request, *iam.DeleteLoginProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLoginProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteLoginProfileOutput) + return ret0, ret1 +} + +// DeleteLoginProfileRequest indicates an expected call of DeleteLoginProfileRequest +func (mr *MockIAMAPIMockRecorder) DeleteLoginProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoginProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteLoginProfileRequest), arg0) +} + +// DeleteLoginProfileWithContext mocks base method +func (m *MockIAMAPI) DeleteLoginProfileWithContext(arg0 context.Context, arg1 *iam.DeleteLoginProfileInput, arg2 ...request.Option) (*iam.DeleteLoginProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLoginProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteLoginProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLoginProfileWithContext indicates an expected call of DeleteLoginProfileWithContext +func (mr *MockIAMAPIMockRecorder) DeleteLoginProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoginProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteLoginProfileWithContext), varargs...) +} + +// DeleteOpenIDConnectProvider mocks base method +func (m *MockIAMAPI) DeleteOpenIDConnectProvider(arg0 *iam.DeleteOpenIDConnectProviderInput) (*iam.DeleteOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOpenIDConnectProvider", arg0) + ret0, _ := ret[0].(*iam.DeleteOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOpenIDConnectProvider indicates an expected call of DeleteOpenIDConnectProvider +func (mr *MockIAMAPIMockRecorder) DeleteOpenIDConnectProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpenIDConnectProvider", reflect.TypeOf((*MockIAMAPI)(nil).DeleteOpenIDConnectProvider), arg0) +} + +// DeleteOpenIDConnectProviderRequest mocks base method +func (m *MockIAMAPI) DeleteOpenIDConnectProviderRequest(arg0 *iam.DeleteOpenIDConnectProviderInput) (*request.Request, *iam.DeleteOpenIDConnectProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOpenIDConnectProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteOpenIDConnectProviderOutput) + return ret0, ret1 +} + +// DeleteOpenIDConnectProviderRequest indicates an expected call of DeleteOpenIDConnectProviderRequest +func (mr *MockIAMAPIMockRecorder) DeleteOpenIDConnectProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpenIDConnectProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteOpenIDConnectProviderRequest), arg0) +} + +// DeleteOpenIDConnectProviderWithContext mocks base method +func (m *MockIAMAPI) DeleteOpenIDConnectProviderWithContext(arg0 context.Context, arg1 *iam.DeleteOpenIDConnectProviderInput, arg2 ...request.Option) (*iam.DeleteOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteOpenIDConnectProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteOpenIDConnectProviderWithContext indicates an expected call of DeleteOpenIDConnectProviderWithContext +func (mr *MockIAMAPIMockRecorder) DeleteOpenIDConnectProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpenIDConnectProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteOpenIDConnectProviderWithContext), varargs...) +} + +// DeletePolicy mocks base method +func (m *MockIAMAPI) DeletePolicy(arg0 *iam.DeletePolicyInput) (*iam.DeletePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePolicy", arg0) + ret0, _ := ret[0].(*iam.DeletePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePolicy indicates an expected call of DeletePolicy +func (mr *MockIAMAPIMockRecorder) DeletePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicy", reflect.TypeOf((*MockIAMAPI)(nil).DeletePolicy), arg0) +} + +// DeletePolicyRequest mocks base method +func (m *MockIAMAPI) DeletePolicyRequest(arg0 *iam.DeletePolicyInput) (*request.Request, *iam.DeletePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeletePolicyOutput) + return ret0, ret1 +} + +// DeletePolicyRequest indicates an expected call of DeletePolicyRequest +func (mr *MockIAMAPIMockRecorder) DeletePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeletePolicyRequest), arg0) +} + +// DeletePolicyVersion mocks base method +func (m *MockIAMAPI) DeletePolicyVersion(arg0 *iam.DeletePolicyVersionInput) (*iam.DeletePolicyVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePolicyVersion", arg0) + ret0, _ := ret[0].(*iam.DeletePolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePolicyVersion indicates an expected call of DeletePolicyVersion +func (mr *MockIAMAPIMockRecorder) DeletePolicyVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyVersion", reflect.TypeOf((*MockIAMAPI)(nil).DeletePolicyVersion), arg0) +} + +// DeletePolicyVersionRequest mocks base method +func (m *MockIAMAPI) DeletePolicyVersionRequest(arg0 *iam.DeletePolicyVersionInput) (*request.Request, *iam.DeletePolicyVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePolicyVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeletePolicyVersionOutput) + return ret0, ret1 +} + +// DeletePolicyVersionRequest indicates an expected call of DeletePolicyVersionRequest +func (mr *MockIAMAPIMockRecorder) DeletePolicyVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyVersionRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeletePolicyVersionRequest), arg0) +} + +// DeletePolicyVersionWithContext mocks base method +func (m *MockIAMAPI) DeletePolicyVersionWithContext(arg0 context.Context, arg1 *iam.DeletePolicyVersionInput, arg2 ...request.Option) (*iam.DeletePolicyVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePolicyVersionWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeletePolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePolicyVersionWithContext indicates an expected call of DeletePolicyVersionWithContext +func (mr *MockIAMAPIMockRecorder) DeletePolicyVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyVersionWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeletePolicyVersionWithContext), varargs...) +} + +// DeletePolicyWithContext mocks base method +func (m *MockIAMAPI) DeletePolicyWithContext(arg0 context.Context, arg1 *iam.DeletePolicyInput, arg2 ...request.Option) (*iam.DeletePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeletePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePolicyWithContext indicates an expected call of DeletePolicyWithContext +func (mr *MockIAMAPIMockRecorder) DeletePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeletePolicyWithContext), varargs...) +} + +// DeleteRole mocks base method +func (m *MockIAMAPI) DeleteRole(arg0 *iam.DeleteRoleInput) (*iam.DeleteRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRole", arg0) + ret0, _ := ret[0].(*iam.DeleteRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRole indicates an expected call of DeleteRole +func (mr *MockIAMAPIMockRecorder) DeleteRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRole", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRole), arg0) +} + +// DeleteRolePermissionsBoundary mocks base method +func (m *MockIAMAPI) DeleteRolePermissionsBoundary(arg0 *iam.DeleteRolePermissionsBoundaryInput) (*iam.DeleteRolePermissionsBoundaryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRolePermissionsBoundary", arg0) + ret0, _ := ret[0].(*iam.DeleteRolePermissionsBoundaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRolePermissionsBoundary indicates an expected call of DeleteRolePermissionsBoundary +func (mr *MockIAMAPIMockRecorder) DeleteRolePermissionsBoundary(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRolePermissionsBoundary", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRolePermissionsBoundary), arg0) +} + +// DeleteRolePermissionsBoundaryRequest mocks base method +func (m *MockIAMAPI) DeleteRolePermissionsBoundaryRequest(arg0 *iam.DeleteRolePermissionsBoundaryInput) (*request.Request, *iam.DeleteRolePermissionsBoundaryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRolePermissionsBoundaryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteRolePermissionsBoundaryOutput) + return ret0, ret1 +} + +// DeleteRolePermissionsBoundaryRequest indicates an expected call of DeleteRolePermissionsBoundaryRequest +func (mr *MockIAMAPIMockRecorder) DeleteRolePermissionsBoundaryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRolePermissionsBoundaryRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRolePermissionsBoundaryRequest), arg0) +} + +// DeleteRolePermissionsBoundaryWithContext mocks base method +func (m *MockIAMAPI) DeleteRolePermissionsBoundaryWithContext(arg0 context.Context, arg1 *iam.DeleteRolePermissionsBoundaryInput, arg2 ...request.Option) (*iam.DeleteRolePermissionsBoundaryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRolePermissionsBoundaryWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteRolePermissionsBoundaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRolePermissionsBoundaryWithContext indicates an expected call of DeleteRolePermissionsBoundaryWithContext +func (mr *MockIAMAPIMockRecorder) DeleteRolePermissionsBoundaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRolePermissionsBoundaryWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRolePermissionsBoundaryWithContext), varargs...) +} + +// DeleteRolePolicy mocks base method +func (m *MockIAMAPI) DeleteRolePolicy(arg0 *iam.DeleteRolePolicyInput) (*iam.DeleteRolePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRolePolicy", arg0) + ret0, _ := ret[0].(*iam.DeleteRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRolePolicy indicates an expected call of DeleteRolePolicy +func (mr *MockIAMAPIMockRecorder) DeleteRolePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRolePolicy", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRolePolicy), arg0) +} + +// DeleteRolePolicyRequest mocks base method +func (m *MockIAMAPI) DeleteRolePolicyRequest(arg0 *iam.DeleteRolePolicyInput) (*request.Request, *iam.DeleteRolePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRolePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteRolePolicyOutput) + return ret0, ret1 +} + +// DeleteRolePolicyRequest indicates an expected call of DeleteRolePolicyRequest +func (mr *MockIAMAPIMockRecorder) DeleteRolePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRolePolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRolePolicyRequest), arg0) +} + +// DeleteRolePolicyWithContext mocks base method +func (m *MockIAMAPI) DeleteRolePolicyWithContext(arg0 context.Context, arg1 *iam.DeleteRolePolicyInput, arg2 ...request.Option) (*iam.DeleteRolePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRolePolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRolePolicyWithContext indicates an expected call of DeleteRolePolicyWithContext +func (mr *MockIAMAPIMockRecorder) DeleteRolePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRolePolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRolePolicyWithContext), varargs...) +} + +// DeleteRoleRequest mocks base method +func (m *MockIAMAPI) DeleteRoleRequest(arg0 *iam.DeleteRoleInput) (*request.Request, *iam.DeleteRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteRoleOutput) + return ret0, ret1 +} + +// DeleteRoleRequest indicates an expected call of DeleteRoleRequest +func (mr *MockIAMAPIMockRecorder) DeleteRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRoleRequest), arg0) +} + +// DeleteRoleWithContext mocks base method +func (m *MockIAMAPI) DeleteRoleWithContext(arg0 context.Context, arg1 *iam.DeleteRoleInput, arg2 ...request.Option) (*iam.DeleteRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteRoleWithContext indicates an expected call of DeleteRoleWithContext +func (mr *MockIAMAPIMockRecorder) DeleteRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteRoleWithContext), varargs...) +} + +// DeleteSAMLProvider mocks base method +func (m *MockIAMAPI) DeleteSAMLProvider(arg0 *iam.DeleteSAMLProviderInput) (*iam.DeleteSAMLProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSAMLProvider", arg0) + ret0, _ := ret[0].(*iam.DeleteSAMLProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSAMLProvider indicates an expected call of DeleteSAMLProvider +func (mr *MockIAMAPIMockRecorder) DeleteSAMLProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSAMLProvider", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSAMLProvider), arg0) +} + +// DeleteSAMLProviderRequest mocks base method +func (m *MockIAMAPI) DeleteSAMLProviderRequest(arg0 *iam.DeleteSAMLProviderInput) (*request.Request, *iam.DeleteSAMLProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSAMLProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteSAMLProviderOutput) + return ret0, ret1 +} + +// DeleteSAMLProviderRequest indicates an expected call of DeleteSAMLProviderRequest +func (mr *MockIAMAPIMockRecorder) DeleteSAMLProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSAMLProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSAMLProviderRequest), arg0) +} + +// DeleteSAMLProviderWithContext mocks base method +func (m *MockIAMAPI) DeleteSAMLProviderWithContext(arg0 context.Context, arg1 *iam.DeleteSAMLProviderInput, arg2 ...request.Option) (*iam.DeleteSAMLProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteSAMLProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteSAMLProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSAMLProviderWithContext indicates an expected call of DeleteSAMLProviderWithContext +func (mr *MockIAMAPIMockRecorder) DeleteSAMLProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSAMLProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSAMLProviderWithContext), varargs...) +} + +// DeleteSSHPublicKey mocks base method +func (m *MockIAMAPI) DeleteSSHPublicKey(arg0 *iam.DeleteSSHPublicKeyInput) (*iam.DeleteSSHPublicKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSSHPublicKey", arg0) + ret0, _ := ret[0].(*iam.DeleteSSHPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSSHPublicKey indicates an expected call of DeleteSSHPublicKey +func (mr *MockIAMAPIMockRecorder) DeleteSSHPublicKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSSHPublicKey", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSSHPublicKey), arg0) +} + +// DeleteSSHPublicKeyRequest mocks base method +func (m *MockIAMAPI) DeleteSSHPublicKeyRequest(arg0 *iam.DeleteSSHPublicKeyInput) (*request.Request, *iam.DeleteSSHPublicKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSSHPublicKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteSSHPublicKeyOutput) + return ret0, ret1 +} + +// DeleteSSHPublicKeyRequest indicates an expected call of DeleteSSHPublicKeyRequest +func (mr *MockIAMAPIMockRecorder) DeleteSSHPublicKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSSHPublicKeyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSSHPublicKeyRequest), arg0) +} + +// DeleteSSHPublicKeyWithContext mocks base method +func (m *MockIAMAPI) DeleteSSHPublicKeyWithContext(arg0 context.Context, arg1 *iam.DeleteSSHPublicKeyInput, arg2 ...request.Option) (*iam.DeleteSSHPublicKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteSSHPublicKeyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteSSHPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSSHPublicKeyWithContext indicates an expected call of DeleteSSHPublicKeyWithContext +func (mr *MockIAMAPIMockRecorder) DeleteSSHPublicKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSSHPublicKeyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSSHPublicKeyWithContext), varargs...) +} + +// DeleteServerCertificate mocks base method +func (m *MockIAMAPI) DeleteServerCertificate(arg0 *iam.DeleteServerCertificateInput) (*iam.DeleteServerCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteServerCertificate", arg0) + ret0, _ := ret[0].(*iam.DeleteServerCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteServerCertificate indicates an expected call of DeleteServerCertificate +func (mr *MockIAMAPIMockRecorder) DeleteServerCertificate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServerCertificate", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServerCertificate), arg0) +} + +// DeleteServerCertificateRequest mocks base method +func (m *MockIAMAPI) DeleteServerCertificateRequest(arg0 *iam.DeleteServerCertificateInput) (*request.Request, *iam.DeleteServerCertificateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteServerCertificateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteServerCertificateOutput) + return ret0, ret1 +} + +// DeleteServerCertificateRequest indicates an expected call of DeleteServerCertificateRequest +func (mr *MockIAMAPIMockRecorder) DeleteServerCertificateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServerCertificateRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServerCertificateRequest), arg0) +} + +// DeleteServerCertificateWithContext mocks base method +func (m *MockIAMAPI) DeleteServerCertificateWithContext(arg0 context.Context, arg1 *iam.DeleteServerCertificateInput, arg2 ...request.Option) (*iam.DeleteServerCertificateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteServerCertificateWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteServerCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteServerCertificateWithContext indicates an expected call of DeleteServerCertificateWithContext +func (mr *MockIAMAPIMockRecorder) DeleteServerCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServerCertificateWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServerCertificateWithContext), varargs...) +} + +// DeleteServiceLinkedRole mocks base method +func (m *MockIAMAPI) DeleteServiceLinkedRole(arg0 *iam.DeleteServiceLinkedRoleInput) (*iam.DeleteServiceLinkedRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteServiceLinkedRole", arg0) + ret0, _ := ret[0].(*iam.DeleteServiceLinkedRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteServiceLinkedRole indicates an expected call of DeleteServiceLinkedRole +func (mr *MockIAMAPIMockRecorder) DeleteServiceLinkedRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceLinkedRole", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServiceLinkedRole), arg0) +} + +// DeleteServiceLinkedRoleRequest mocks base method +func (m *MockIAMAPI) DeleteServiceLinkedRoleRequest(arg0 *iam.DeleteServiceLinkedRoleInput) (*request.Request, *iam.DeleteServiceLinkedRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteServiceLinkedRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteServiceLinkedRoleOutput) + return ret0, ret1 +} + +// DeleteServiceLinkedRoleRequest indicates an expected call of DeleteServiceLinkedRoleRequest +func (mr *MockIAMAPIMockRecorder) DeleteServiceLinkedRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceLinkedRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServiceLinkedRoleRequest), arg0) +} + +// DeleteServiceLinkedRoleWithContext mocks base method +func (m *MockIAMAPI) DeleteServiceLinkedRoleWithContext(arg0 context.Context, arg1 *iam.DeleteServiceLinkedRoleInput, arg2 ...request.Option) (*iam.DeleteServiceLinkedRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteServiceLinkedRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteServiceLinkedRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteServiceLinkedRoleWithContext indicates an expected call of DeleteServiceLinkedRoleWithContext +func (mr *MockIAMAPIMockRecorder) DeleteServiceLinkedRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceLinkedRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServiceLinkedRoleWithContext), varargs...) +} + +// DeleteServiceSpecificCredential mocks base method +func (m *MockIAMAPI) DeleteServiceSpecificCredential(arg0 *iam.DeleteServiceSpecificCredentialInput) (*iam.DeleteServiceSpecificCredentialOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteServiceSpecificCredential", arg0) + ret0, _ := ret[0].(*iam.DeleteServiceSpecificCredentialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteServiceSpecificCredential indicates an expected call of DeleteServiceSpecificCredential +func (mr *MockIAMAPIMockRecorder) DeleteServiceSpecificCredential(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceSpecificCredential", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServiceSpecificCredential), arg0) +} + +// DeleteServiceSpecificCredentialRequest mocks base method +func (m *MockIAMAPI) DeleteServiceSpecificCredentialRequest(arg0 *iam.DeleteServiceSpecificCredentialInput) (*request.Request, *iam.DeleteServiceSpecificCredentialOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteServiceSpecificCredentialRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteServiceSpecificCredentialOutput) + return ret0, ret1 +} + +// DeleteServiceSpecificCredentialRequest indicates an expected call of DeleteServiceSpecificCredentialRequest +func (mr *MockIAMAPIMockRecorder) DeleteServiceSpecificCredentialRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceSpecificCredentialRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServiceSpecificCredentialRequest), arg0) +} + +// DeleteServiceSpecificCredentialWithContext mocks base method +func (m *MockIAMAPI) DeleteServiceSpecificCredentialWithContext(arg0 context.Context, arg1 *iam.DeleteServiceSpecificCredentialInput, arg2 ...request.Option) (*iam.DeleteServiceSpecificCredentialOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteServiceSpecificCredentialWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteServiceSpecificCredentialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteServiceSpecificCredentialWithContext indicates an expected call of DeleteServiceSpecificCredentialWithContext +func (mr *MockIAMAPIMockRecorder) DeleteServiceSpecificCredentialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceSpecificCredentialWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteServiceSpecificCredentialWithContext), varargs...) +} + +// DeleteSigningCertificate mocks base method +func (m *MockIAMAPI) DeleteSigningCertificate(arg0 *iam.DeleteSigningCertificateInput) (*iam.DeleteSigningCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSigningCertificate", arg0) + ret0, _ := ret[0].(*iam.DeleteSigningCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSigningCertificate indicates an expected call of DeleteSigningCertificate +func (mr *MockIAMAPIMockRecorder) DeleteSigningCertificate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSigningCertificate", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSigningCertificate), arg0) +} + +// DeleteSigningCertificateRequest mocks base method +func (m *MockIAMAPI) DeleteSigningCertificateRequest(arg0 *iam.DeleteSigningCertificateInput) (*request.Request, *iam.DeleteSigningCertificateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteSigningCertificateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteSigningCertificateOutput) + return ret0, ret1 +} + +// DeleteSigningCertificateRequest indicates an expected call of DeleteSigningCertificateRequest +func (mr *MockIAMAPIMockRecorder) DeleteSigningCertificateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSigningCertificateRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSigningCertificateRequest), arg0) +} + +// DeleteSigningCertificateWithContext mocks base method +func (m *MockIAMAPI) DeleteSigningCertificateWithContext(arg0 context.Context, arg1 *iam.DeleteSigningCertificateInput, arg2 ...request.Option) (*iam.DeleteSigningCertificateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteSigningCertificateWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteSigningCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteSigningCertificateWithContext indicates an expected call of DeleteSigningCertificateWithContext +func (mr *MockIAMAPIMockRecorder) DeleteSigningCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSigningCertificateWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteSigningCertificateWithContext), varargs...) +} + +// DeleteUser mocks base method +func (m *MockIAMAPI) DeleteUser(arg0 *iam.DeleteUserInput) (*iam.DeleteUserOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteUser", arg0) + ret0, _ := ret[0].(*iam.DeleteUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteUser indicates an expected call of DeleteUser +func (mr *MockIAMAPIMockRecorder) DeleteUser(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUser), arg0) +} + +// DeleteUserPermissionsBoundary mocks base method +func (m *MockIAMAPI) DeleteUserPermissionsBoundary(arg0 *iam.DeleteUserPermissionsBoundaryInput) (*iam.DeleteUserPermissionsBoundaryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteUserPermissionsBoundary", arg0) + ret0, _ := ret[0].(*iam.DeleteUserPermissionsBoundaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteUserPermissionsBoundary indicates an expected call of DeleteUserPermissionsBoundary +func (mr *MockIAMAPIMockRecorder) DeleteUserPermissionsBoundary(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPermissionsBoundary", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUserPermissionsBoundary), arg0) +} + +// DeleteUserPermissionsBoundaryRequest mocks base method +func (m *MockIAMAPI) DeleteUserPermissionsBoundaryRequest(arg0 *iam.DeleteUserPermissionsBoundaryInput) (*request.Request, *iam.DeleteUserPermissionsBoundaryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteUserPermissionsBoundaryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteUserPermissionsBoundaryOutput) + return ret0, ret1 +} + +// DeleteUserPermissionsBoundaryRequest indicates an expected call of DeleteUserPermissionsBoundaryRequest +func (mr *MockIAMAPIMockRecorder) DeleteUserPermissionsBoundaryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPermissionsBoundaryRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUserPermissionsBoundaryRequest), arg0) +} + +// DeleteUserPermissionsBoundaryWithContext mocks base method +func (m *MockIAMAPI) DeleteUserPermissionsBoundaryWithContext(arg0 context.Context, arg1 *iam.DeleteUserPermissionsBoundaryInput, arg2 ...request.Option) (*iam.DeleteUserPermissionsBoundaryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteUserPermissionsBoundaryWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteUserPermissionsBoundaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteUserPermissionsBoundaryWithContext indicates an expected call of DeleteUserPermissionsBoundaryWithContext +func (mr *MockIAMAPIMockRecorder) DeleteUserPermissionsBoundaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPermissionsBoundaryWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUserPermissionsBoundaryWithContext), varargs...) +} + +// DeleteUserPolicy mocks base method +func (m *MockIAMAPI) DeleteUserPolicy(arg0 *iam.DeleteUserPolicyInput) (*iam.DeleteUserPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteUserPolicy", arg0) + ret0, _ := ret[0].(*iam.DeleteUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteUserPolicy indicates an expected call of DeleteUserPolicy +func (mr *MockIAMAPIMockRecorder) DeleteUserPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPolicy", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUserPolicy), arg0) +} + +// DeleteUserPolicyRequest mocks base method +func (m *MockIAMAPI) DeleteUserPolicyRequest(arg0 *iam.DeleteUserPolicyInput) (*request.Request, *iam.DeleteUserPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteUserPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteUserPolicyOutput) + return ret0, ret1 +} + +// DeleteUserPolicyRequest indicates an expected call of DeleteUserPolicyRequest +func (mr *MockIAMAPIMockRecorder) DeleteUserPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUserPolicyRequest), arg0) +} + +// DeleteUserPolicyWithContext mocks base method +func (m *MockIAMAPI) DeleteUserPolicyWithContext(arg0 context.Context, arg1 *iam.DeleteUserPolicyInput, arg2 ...request.Option) (*iam.DeleteUserPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteUserPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteUserPolicyWithContext indicates an expected call of DeleteUserPolicyWithContext +func (mr *MockIAMAPIMockRecorder) DeleteUserPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUserPolicyWithContext), varargs...) +} + +// DeleteUserRequest mocks base method +func (m *MockIAMAPI) DeleteUserRequest(arg0 *iam.DeleteUserInput) (*request.Request, *iam.DeleteUserOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteUserRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteUserOutput) + return ret0, ret1 +} + +// DeleteUserRequest indicates an expected call of DeleteUserRequest +func (mr *MockIAMAPIMockRecorder) DeleteUserRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUserRequest), arg0) +} + +// DeleteUserWithContext mocks base method +func (m *MockIAMAPI) DeleteUserWithContext(arg0 context.Context, arg1 *iam.DeleteUserInput, arg2 ...request.Option) (*iam.DeleteUserOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteUserWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteUserWithContext indicates an expected call of DeleteUserWithContext +func (mr *MockIAMAPIMockRecorder) DeleteUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteUserWithContext), varargs...) +} + +// DeleteVirtualMFADevice mocks base method +func (m *MockIAMAPI) DeleteVirtualMFADevice(arg0 *iam.DeleteVirtualMFADeviceInput) (*iam.DeleteVirtualMFADeviceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVirtualMFADevice", arg0) + ret0, _ := ret[0].(*iam.DeleteVirtualMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVirtualMFADevice indicates an expected call of DeleteVirtualMFADevice +func (mr *MockIAMAPIMockRecorder) DeleteVirtualMFADevice(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMFADevice", reflect.TypeOf((*MockIAMAPI)(nil).DeleteVirtualMFADevice), arg0) +} + +// DeleteVirtualMFADeviceRequest mocks base method +func (m *MockIAMAPI) DeleteVirtualMFADeviceRequest(arg0 *iam.DeleteVirtualMFADeviceInput) (*request.Request, *iam.DeleteVirtualMFADeviceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteVirtualMFADeviceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DeleteVirtualMFADeviceOutput) + return ret0, ret1 +} + +// DeleteVirtualMFADeviceRequest indicates an expected call of DeleteVirtualMFADeviceRequest +func (mr *MockIAMAPIMockRecorder) DeleteVirtualMFADeviceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMFADeviceRequest", reflect.TypeOf((*MockIAMAPI)(nil).DeleteVirtualMFADeviceRequest), arg0) +} + +// DeleteVirtualMFADeviceWithContext mocks base method +func (m *MockIAMAPI) DeleteVirtualMFADeviceWithContext(arg0 context.Context, arg1 *iam.DeleteVirtualMFADeviceInput, arg2 ...request.Option) (*iam.DeleteVirtualMFADeviceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteVirtualMFADeviceWithContext", varargs...) + ret0, _ := ret[0].(*iam.DeleteVirtualMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteVirtualMFADeviceWithContext indicates an expected call of DeleteVirtualMFADeviceWithContext +func (mr *MockIAMAPIMockRecorder) DeleteVirtualMFADeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMFADeviceWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DeleteVirtualMFADeviceWithContext), varargs...) +} + +// DetachGroupPolicy mocks base method +func (m *MockIAMAPI) DetachGroupPolicy(arg0 *iam.DetachGroupPolicyInput) (*iam.DetachGroupPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachGroupPolicy", arg0) + ret0, _ := ret[0].(*iam.DetachGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachGroupPolicy indicates an expected call of DetachGroupPolicy +func (mr *MockIAMAPIMockRecorder) DetachGroupPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachGroupPolicy", reflect.TypeOf((*MockIAMAPI)(nil).DetachGroupPolicy), arg0) +} + +// DetachGroupPolicyRequest mocks base method +func (m *MockIAMAPI) DetachGroupPolicyRequest(arg0 *iam.DetachGroupPolicyInput) (*request.Request, *iam.DetachGroupPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachGroupPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DetachGroupPolicyOutput) + return ret0, ret1 +} + +// DetachGroupPolicyRequest indicates an expected call of DetachGroupPolicyRequest +func (mr *MockIAMAPIMockRecorder) DetachGroupPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachGroupPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DetachGroupPolicyRequest), arg0) +} + +// DetachGroupPolicyWithContext mocks base method +func (m *MockIAMAPI) DetachGroupPolicyWithContext(arg0 context.Context, arg1 *iam.DetachGroupPolicyInput, arg2 ...request.Option) (*iam.DetachGroupPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachGroupPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DetachGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachGroupPolicyWithContext indicates an expected call of DetachGroupPolicyWithContext +func (mr *MockIAMAPIMockRecorder) DetachGroupPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachGroupPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DetachGroupPolicyWithContext), varargs...) +} + +// DetachRolePolicy mocks base method +func (m *MockIAMAPI) DetachRolePolicy(arg0 *iam.DetachRolePolicyInput) (*iam.DetachRolePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachRolePolicy", arg0) + ret0, _ := ret[0].(*iam.DetachRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachRolePolicy indicates an expected call of DetachRolePolicy +func (mr *MockIAMAPIMockRecorder) DetachRolePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachRolePolicy", reflect.TypeOf((*MockIAMAPI)(nil).DetachRolePolicy), arg0) +} + +// DetachRolePolicyRequest mocks base method +func (m *MockIAMAPI) DetachRolePolicyRequest(arg0 *iam.DetachRolePolicyInput) (*request.Request, *iam.DetachRolePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachRolePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DetachRolePolicyOutput) + return ret0, ret1 +} + +// DetachRolePolicyRequest indicates an expected call of DetachRolePolicyRequest +func (mr *MockIAMAPIMockRecorder) DetachRolePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachRolePolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DetachRolePolicyRequest), arg0) +} + +// DetachRolePolicyWithContext mocks base method +func (m *MockIAMAPI) DetachRolePolicyWithContext(arg0 context.Context, arg1 *iam.DetachRolePolicyInput, arg2 ...request.Option) (*iam.DetachRolePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachRolePolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DetachRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachRolePolicyWithContext indicates an expected call of DetachRolePolicyWithContext +func (mr *MockIAMAPIMockRecorder) DetachRolePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachRolePolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DetachRolePolicyWithContext), varargs...) +} + +// DetachUserPolicy mocks base method +func (m *MockIAMAPI) DetachUserPolicy(arg0 *iam.DetachUserPolicyInput) (*iam.DetachUserPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachUserPolicy", arg0) + ret0, _ := ret[0].(*iam.DetachUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachUserPolicy indicates an expected call of DetachUserPolicy +func (mr *MockIAMAPIMockRecorder) DetachUserPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachUserPolicy", reflect.TypeOf((*MockIAMAPI)(nil).DetachUserPolicy), arg0) +} + +// DetachUserPolicyRequest mocks base method +func (m *MockIAMAPI) DetachUserPolicyRequest(arg0 *iam.DetachUserPolicyInput) (*request.Request, *iam.DetachUserPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachUserPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.DetachUserPolicyOutput) + return ret0, ret1 +} + +// DetachUserPolicyRequest indicates an expected call of DetachUserPolicyRequest +func (mr *MockIAMAPIMockRecorder) DetachUserPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachUserPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).DetachUserPolicyRequest), arg0) +} + +// DetachUserPolicyWithContext mocks base method +func (m *MockIAMAPI) DetachUserPolicyWithContext(arg0 context.Context, arg1 *iam.DetachUserPolicyInput, arg2 ...request.Option) (*iam.DetachUserPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachUserPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.DetachUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachUserPolicyWithContext indicates an expected call of DetachUserPolicyWithContext +func (mr *MockIAMAPIMockRecorder) DetachUserPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachUserPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).DetachUserPolicyWithContext), varargs...) +} + +// EnableMFADevice mocks base method +func (m *MockIAMAPI) EnableMFADevice(arg0 *iam.EnableMFADeviceInput) (*iam.EnableMFADeviceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableMFADevice", arg0) + ret0, _ := ret[0].(*iam.EnableMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableMFADevice indicates an expected call of EnableMFADevice +func (mr *MockIAMAPIMockRecorder) EnableMFADevice(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMFADevice", reflect.TypeOf((*MockIAMAPI)(nil).EnableMFADevice), arg0) +} + +// EnableMFADeviceRequest mocks base method +func (m *MockIAMAPI) EnableMFADeviceRequest(arg0 *iam.EnableMFADeviceInput) (*request.Request, *iam.EnableMFADeviceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableMFADeviceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.EnableMFADeviceOutput) + return ret0, ret1 +} + +// EnableMFADeviceRequest indicates an expected call of EnableMFADeviceRequest +func (mr *MockIAMAPIMockRecorder) EnableMFADeviceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMFADeviceRequest", reflect.TypeOf((*MockIAMAPI)(nil).EnableMFADeviceRequest), arg0) +} + +// EnableMFADeviceWithContext mocks base method +func (m *MockIAMAPI) EnableMFADeviceWithContext(arg0 context.Context, arg1 *iam.EnableMFADeviceInput, arg2 ...request.Option) (*iam.EnableMFADeviceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableMFADeviceWithContext", varargs...) + ret0, _ := ret[0].(*iam.EnableMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableMFADeviceWithContext indicates an expected call of EnableMFADeviceWithContext +func (mr *MockIAMAPIMockRecorder) EnableMFADeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMFADeviceWithContext", reflect.TypeOf((*MockIAMAPI)(nil).EnableMFADeviceWithContext), varargs...) +} + +// GenerateCredentialReport mocks base method +func (m *MockIAMAPI) GenerateCredentialReport(arg0 *iam.GenerateCredentialReportInput) (*iam.GenerateCredentialReportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateCredentialReport", arg0) + ret0, _ := ret[0].(*iam.GenerateCredentialReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateCredentialReport indicates an expected call of GenerateCredentialReport +func (mr *MockIAMAPIMockRecorder) GenerateCredentialReport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateCredentialReport", reflect.TypeOf((*MockIAMAPI)(nil).GenerateCredentialReport), arg0) +} + +// GenerateCredentialReportRequest mocks base method +func (m *MockIAMAPI) GenerateCredentialReportRequest(arg0 *iam.GenerateCredentialReportInput) (*request.Request, *iam.GenerateCredentialReportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateCredentialReportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GenerateCredentialReportOutput) + return ret0, ret1 +} + +// GenerateCredentialReportRequest indicates an expected call of GenerateCredentialReportRequest +func (mr *MockIAMAPIMockRecorder) GenerateCredentialReportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateCredentialReportRequest", reflect.TypeOf((*MockIAMAPI)(nil).GenerateCredentialReportRequest), arg0) +} + +// GenerateCredentialReportWithContext mocks base method +func (m *MockIAMAPI) GenerateCredentialReportWithContext(arg0 context.Context, arg1 *iam.GenerateCredentialReportInput, arg2 ...request.Option) (*iam.GenerateCredentialReportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateCredentialReportWithContext", varargs...) + ret0, _ := ret[0].(*iam.GenerateCredentialReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateCredentialReportWithContext indicates an expected call of GenerateCredentialReportWithContext +func (mr *MockIAMAPIMockRecorder) GenerateCredentialReportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateCredentialReportWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GenerateCredentialReportWithContext), varargs...) +} + +// GenerateOrganizationsAccessReport mocks base method +func (m *MockIAMAPI) GenerateOrganizationsAccessReport(arg0 *iam.GenerateOrganizationsAccessReportInput) (*iam.GenerateOrganizationsAccessReportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateOrganizationsAccessReport", arg0) + ret0, _ := ret[0].(*iam.GenerateOrganizationsAccessReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateOrganizationsAccessReport indicates an expected call of GenerateOrganizationsAccessReport +func (mr *MockIAMAPIMockRecorder) GenerateOrganizationsAccessReport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateOrganizationsAccessReport", reflect.TypeOf((*MockIAMAPI)(nil).GenerateOrganizationsAccessReport), arg0) +} + +// GenerateOrganizationsAccessReportRequest mocks base method +func (m *MockIAMAPI) GenerateOrganizationsAccessReportRequest(arg0 *iam.GenerateOrganizationsAccessReportInput) (*request.Request, *iam.GenerateOrganizationsAccessReportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateOrganizationsAccessReportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GenerateOrganizationsAccessReportOutput) + return ret0, ret1 +} + +// GenerateOrganizationsAccessReportRequest indicates an expected call of GenerateOrganizationsAccessReportRequest +func (mr *MockIAMAPIMockRecorder) GenerateOrganizationsAccessReportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateOrganizationsAccessReportRequest", reflect.TypeOf((*MockIAMAPI)(nil).GenerateOrganizationsAccessReportRequest), arg0) +} + +// GenerateOrganizationsAccessReportWithContext mocks base method +func (m *MockIAMAPI) GenerateOrganizationsAccessReportWithContext(arg0 context.Context, arg1 *iam.GenerateOrganizationsAccessReportInput, arg2 ...request.Option) (*iam.GenerateOrganizationsAccessReportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateOrganizationsAccessReportWithContext", varargs...) + ret0, _ := ret[0].(*iam.GenerateOrganizationsAccessReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateOrganizationsAccessReportWithContext indicates an expected call of GenerateOrganizationsAccessReportWithContext +func (mr *MockIAMAPIMockRecorder) GenerateOrganizationsAccessReportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateOrganizationsAccessReportWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GenerateOrganizationsAccessReportWithContext), varargs...) +} + +// GenerateServiceLastAccessedDetails mocks base method +func (m *MockIAMAPI) GenerateServiceLastAccessedDetails(arg0 *iam.GenerateServiceLastAccessedDetailsInput) (*iam.GenerateServiceLastAccessedDetailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateServiceLastAccessedDetails", arg0) + ret0, _ := ret[0].(*iam.GenerateServiceLastAccessedDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateServiceLastAccessedDetails indicates an expected call of GenerateServiceLastAccessedDetails +func (mr *MockIAMAPIMockRecorder) GenerateServiceLastAccessedDetails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateServiceLastAccessedDetails", reflect.TypeOf((*MockIAMAPI)(nil).GenerateServiceLastAccessedDetails), arg0) +} + +// GenerateServiceLastAccessedDetailsRequest mocks base method +func (m *MockIAMAPI) GenerateServiceLastAccessedDetailsRequest(arg0 *iam.GenerateServiceLastAccessedDetailsInput) (*request.Request, *iam.GenerateServiceLastAccessedDetailsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateServiceLastAccessedDetailsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GenerateServiceLastAccessedDetailsOutput) + return ret0, ret1 +} + +// GenerateServiceLastAccessedDetailsRequest indicates an expected call of GenerateServiceLastAccessedDetailsRequest +func (mr *MockIAMAPIMockRecorder) GenerateServiceLastAccessedDetailsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateServiceLastAccessedDetailsRequest", reflect.TypeOf((*MockIAMAPI)(nil).GenerateServiceLastAccessedDetailsRequest), arg0) +} + +// GenerateServiceLastAccessedDetailsWithContext mocks base method +func (m *MockIAMAPI) GenerateServiceLastAccessedDetailsWithContext(arg0 context.Context, arg1 *iam.GenerateServiceLastAccessedDetailsInput, arg2 ...request.Option) (*iam.GenerateServiceLastAccessedDetailsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateServiceLastAccessedDetailsWithContext", varargs...) + ret0, _ := ret[0].(*iam.GenerateServiceLastAccessedDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateServiceLastAccessedDetailsWithContext indicates an expected call of GenerateServiceLastAccessedDetailsWithContext +func (mr *MockIAMAPIMockRecorder) GenerateServiceLastAccessedDetailsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateServiceLastAccessedDetailsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GenerateServiceLastAccessedDetailsWithContext), varargs...) +} + +// GetAccessKeyLastUsed mocks base method +func (m *MockIAMAPI) GetAccessKeyLastUsed(arg0 *iam.GetAccessKeyLastUsedInput) (*iam.GetAccessKeyLastUsedOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccessKeyLastUsed", arg0) + ret0, _ := ret[0].(*iam.GetAccessKeyLastUsedOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccessKeyLastUsed indicates an expected call of GetAccessKeyLastUsed +func (mr *MockIAMAPIMockRecorder) GetAccessKeyLastUsed(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyLastUsed", reflect.TypeOf((*MockIAMAPI)(nil).GetAccessKeyLastUsed), arg0) +} + +// GetAccessKeyLastUsedRequest mocks base method +func (m *MockIAMAPI) GetAccessKeyLastUsedRequest(arg0 *iam.GetAccessKeyLastUsedInput) (*request.Request, *iam.GetAccessKeyLastUsedOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccessKeyLastUsedRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetAccessKeyLastUsedOutput) + return ret0, ret1 +} + +// GetAccessKeyLastUsedRequest indicates an expected call of GetAccessKeyLastUsedRequest +func (mr *MockIAMAPIMockRecorder) GetAccessKeyLastUsedRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyLastUsedRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetAccessKeyLastUsedRequest), arg0) +} + +// GetAccessKeyLastUsedWithContext mocks base method +func (m *MockIAMAPI) GetAccessKeyLastUsedWithContext(arg0 context.Context, arg1 *iam.GetAccessKeyLastUsedInput, arg2 ...request.Option) (*iam.GetAccessKeyLastUsedOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAccessKeyLastUsedWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetAccessKeyLastUsedOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccessKeyLastUsedWithContext indicates an expected call of GetAccessKeyLastUsedWithContext +func (mr *MockIAMAPIMockRecorder) GetAccessKeyLastUsedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyLastUsedWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetAccessKeyLastUsedWithContext), varargs...) +} + +// GetAccountAuthorizationDetails mocks base method +func (m *MockIAMAPI) GetAccountAuthorizationDetails(arg0 *iam.GetAccountAuthorizationDetailsInput) (*iam.GetAccountAuthorizationDetailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountAuthorizationDetails", arg0) + ret0, _ := ret[0].(*iam.GetAccountAuthorizationDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountAuthorizationDetails indicates an expected call of GetAccountAuthorizationDetails +func (mr *MockIAMAPIMockRecorder) GetAccountAuthorizationDetails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAuthorizationDetails", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountAuthorizationDetails), arg0) +} + +// GetAccountAuthorizationDetailsPages mocks base method +func (m *MockIAMAPI) GetAccountAuthorizationDetailsPages(arg0 *iam.GetAccountAuthorizationDetailsInput, arg1 func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountAuthorizationDetailsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetAccountAuthorizationDetailsPages indicates an expected call of GetAccountAuthorizationDetailsPages +func (mr *MockIAMAPIMockRecorder) GetAccountAuthorizationDetailsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAuthorizationDetailsPages", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountAuthorizationDetailsPages), arg0, arg1) +} + +// GetAccountAuthorizationDetailsPagesWithContext mocks base method +func (m *MockIAMAPI) GetAccountAuthorizationDetailsPagesWithContext(arg0 context.Context, arg1 *iam.GetAccountAuthorizationDetailsInput, arg2 func(*iam.GetAccountAuthorizationDetailsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAccountAuthorizationDetailsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetAccountAuthorizationDetailsPagesWithContext indicates an expected call of GetAccountAuthorizationDetailsPagesWithContext +func (mr *MockIAMAPIMockRecorder) GetAccountAuthorizationDetailsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAuthorizationDetailsPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountAuthorizationDetailsPagesWithContext), varargs...) +} + +// GetAccountAuthorizationDetailsRequest mocks base method +func (m *MockIAMAPI) GetAccountAuthorizationDetailsRequest(arg0 *iam.GetAccountAuthorizationDetailsInput) (*request.Request, *iam.GetAccountAuthorizationDetailsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountAuthorizationDetailsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetAccountAuthorizationDetailsOutput) + return ret0, ret1 +} + +// GetAccountAuthorizationDetailsRequest indicates an expected call of GetAccountAuthorizationDetailsRequest +func (mr *MockIAMAPIMockRecorder) GetAccountAuthorizationDetailsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAuthorizationDetailsRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountAuthorizationDetailsRequest), arg0) +} + +// GetAccountAuthorizationDetailsWithContext mocks base method +func (m *MockIAMAPI) GetAccountAuthorizationDetailsWithContext(arg0 context.Context, arg1 *iam.GetAccountAuthorizationDetailsInput, arg2 ...request.Option) (*iam.GetAccountAuthorizationDetailsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAccountAuthorizationDetailsWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetAccountAuthorizationDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountAuthorizationDetailsWithContext indicates an expected call of GetAccountAuthorizationDetailsWithContext +func (mr *MockIAMAPIMockRecorder) GetAccountAuthorizationDetailsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountAuthorizationDetailsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountAuthorizationDetailsWithContext), varargs...) +} + +// GetAccountPasswordPolicy mocks base method +func (m *MockIAMAPI) GetAccountPasswordPolicy(arg0 *iam.GetAccountPasswordPolicyInput) (*iam.GetAccountPasswordPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountPasswordPolicy", arg0) + ret0, _ := ret[0].(*iam.GetAccountPasswordPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountPasswordPolicy indicates an expected call of GetAccountPasswordPolicy +func (mr *MockIAMAPIMockRecorder) GetAccountPasswordPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountPasswordPolicy", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountPasswordPolicy), arg0) +} + +// GetAccountPasswordPolicyRequest mocks base method +func (m *MockIAMAPI) GetAccountPasswordPolicyRequest(arg0 *iam.GetAccountPasswordPolicyInput) (*request.Request, *iam.GetAccountPasswordPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountPasswordPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetAccountPasswordPolicyOutput) + return ret0, ret1 +} + +// GetAccountPasswordPolicyRequest indicates an expected call of GetAccountPasswordPolicyRequest +func (mr *MockIAMAPIMockRecorder) GetAccountPasswordPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountPasswordPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountPasswordPolicyRequest), arg0) +} + +// GetAccountPasswordPolicyWithContext mocks base method +func (m *MockIAMAPI) GetAccountPasswordPolicyWithContext(arg0 context.Context, arg1 *iam.GetAccountPasswordPolicyInput, arg2 ...request.Option) (*iam.GetAccountPasswordPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAccountPasswordPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetAccountPasswordPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountPasswordPolicyWithContext indicates an expected call of GetAccountPasswordPolicyWithContext +func (mr *MockIAMAPIMockRecorder) GetAccountPasswordPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountPasswordPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountPasswordPolicyWithContext), varargs...) +} + +// GetAccountSummary mocks base method +func (m *MockIAMAPI) GetAccountSummary(arg0 *iam.GetAccountSummaryInput) (*iam.GetAccountSummaryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountSummary", arg0) + ret0, _ := ret[0].(*iam.GetAccountSummaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountSummary indicates an expected call of GetAccountSummary +func (mr *MockIAMAPIMockRecorder) GetAccountSummary(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountSummary", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountSummary), arg0) +} + +// GetAccountSummaryRequest mocks base method +func (m *MockIAMAPI) GetAccountSummaryRequest(arg0 *iam.GetAccountSummaryInput) (*request.Request, *iam.GetAccountSummaryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccountSummaryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetAccountSummaryOutput) + return ret0, ret1 +} + +// GetAccountSummaryRequest indicates an expected call of GetAccountSummaryRequest +func (mr *MockIAMAPIMockRecorder) GetAccountSummaryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountSummaryRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountSummaryRequest), arg0) +} + +// GetAccountSummaryWithContext mocks base method +func (m *MockIAMAPI) GetAccountSummaryWithContext(arg0 context.Context, arg1 *iam.GetAccountSummaryInput, arg2 ...request.Option) (*iam.GetAccountSummaryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAccountSummaryWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetAccountSummaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccountSummaryWithContext indicates an expected call of GetAccountSummaryWithContext +func (mr *MockIAMAPIMockRecorder) GetAccountSummaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountSummaryWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetAccountSummaryWithContext), varargs...) +} + +// GetContextKeysForCustomPolicy mocks base method +func (m *MockIAMAPI) GetContextKeysForCustomPolicy(arg0 *iam.GetContextKeysForCustomPolicyInput) (*iam.GetContextKeysForPolicyResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContextKeysForCustomPolicy", arg0) + ret0, _ := ret[0].(*iam.GetContextKeysForPolicyResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetContextKeysForCustomPolicy indicates an expected call of GetContextKeysForCustomPolicy +func (mr *MockIAMAPIMockRecorder) GetContextKeysForCustomPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContextKeysForCustomPolicy", reflect.TypeOf((*MockIAMAPI)(nil).GetContextKeysForCustomPolicy), arg0) +} + +// GetContextKeysForCustomPolicyRequest mocks base method +func (m *MockIAMAPI) GetContextKeysForCustomPolicyRequest(arg0 *iam.GetContextKeysForCustomPolicyInput) (*request.Request, *iam.GetContextKeysForPolicyResponse) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContextKeysForCustomPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetContextKeysForPolicyResponse) + return ret0, ret1 +} + +// GetContextKeysForCustomPolicyRequest indicates an expected call of GetContextKeysForCustomPolicyRequest +func (mr *MockIAMAPIMockRecorder) GetContextKeysForCustomPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContextKeysForCustomPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetContextKeysForCustomPolicyRequest), arg0) +} + +// GetContextKeysForCustomPolicyWithContext mocks base method +func (m *MockIAMAPI) GetContextKeysForCustomPolicyWithContext(arg0 context.Context, arg1 *iam.GetContextKeysForCustomPolicyInput, arg2 ...request.Option) (*iam.GetContextKeysForPolicyResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetContextKeysForCustomPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetContextKeysForPolicyResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetContextKeysForCustomPolicyWithContext indicates an expected call of GetContextKeysForCustomPolicyWithContext +func (mr *MockIAMAPIMockRecorder) GetContextKeysForCustomPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContextKeysForCustomPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetContextKeysForCustomPolicyWithContext), varargs...) +} + +// GetContextKeysForPrincipalPolicy mocks base method +func (m *MockIAMAPI) GetContextKeysForPrincipalPolicy(arg0 *iam.GetContextKeysForPrincipalPolicyInput) (*iam.GetContextKeysForPolicyResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContextKeysForPrincipalPolicy", arg0) + ret0, _ := ret[0].(*iam.GetContextKeysForPolicyResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetContextKeysForPrincipalPolicy indicates an expected call of GetContextKeysForPrincipalPolicy +func (mr *MockIAMAPIMockRecorder) GetContextKeysForPrincipalPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContextKeysForPrincipalPolicy", reflect.TypeOf((*MockIAMAPI)(nil).GetContextKeysForPrincipalPolicy), arg0) +} + +// GetContextKeysForPrincipalPolicyRequest mocks base method +func (m *MockIAMAPI) GetContextKeysForPrincipalPolicyRequest(arg0 *iam.GetContextKeysForPrincipalPolicyInput) (*request.Request, *iam.GetContextKeysForPolicyResponse) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContextKeysForPrincipalPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetContextKeysForPolicyResponse) + return ret0, ret1 +} + +// GetContextKeysForPrincipalPolicyRequest indicates an expected call of GetContextKeysForPrincipalPolicyRequest +func (mr *MockIAMAPIMockRecorder) GetContextKeysForPrincipalPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContextKeysForPrincipalPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetContextKeysForPrincipalPolicyRequest), arg0) +} + +// GetContextKeysForPrincipalPolicyWithContext mocks base method +func (m *MockIAMAPI) GetContextKeysForPrincipalPolicyWithContext(arg0 context.Context, arg1 *iam.GetContextKeysForPrincipalPolicyInput, arg2 ...request.Option) (*iam.GetContextKeysForPolicyResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetContextKeysForPrincipalPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetContextKeysForPolicyResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetContextKeysForPrincipalPolicyWithContext indicates an expected call of GetContextKeysForPrincipalPolicyWithContext +func (mr *MockIAMAPIMockRecorder) GetContextKeysForPrincipalPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContextKeysForPrincipalPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetContextKeysForPrincipalPolicyWithContext), varargs...) +} + +// GetCredentialReport mocks base method +func (m *MockIAMAPI) GetCredentialReport(arg0 *iam.GetCredentialReportInput) (*iam.GetCredentialReportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCredentialReport", arg0) + ret0, _ := ret[0].(*iam.GetCredentialReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCredentialReport indicates an expected call of GetCredentialReport +func (mr *MockIAMAPIMockRecorder) GetCredentialReport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredentialReport", reflect.TypeOf((*MockIAMAPI)(nil).GetCredentialReport), arg0) +} + +// GetCredentialReportRequest mocks base method +func (m *MockIAMAPI) GetCredentialReportRequest(arg0 *iam.GetCredentialReportInput) (*request.Request, *iam.GetCredentialReportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCredentialReportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetCredentialReportOutput) + return ret0, ret1 +} + +// GetCredentialReportRequest indicates an expected call of GetCredentialReportRequest +func (mr *MockIAMAPIMockRecorder) GetCredentialReportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredentialReportRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetCredentialReportRequest), arg0) +} + +// GetCredentialReportWithContext mocks base method +func (m *MockIAMAPI) GetCredentialReportWithContext(arg0 context.Context, arg1 *iam.GetCredentialReportInput, arg2 ...request.Option) (*iam.GetCredentialReportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetCredentialReportWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetCredentialReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCredentialReportWithContext indicates an expected call of GetCredentialReportWithContext +func (mr *MockIAMAPIMockRecorder) GetCredentialReportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredentialReportWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetCredentialReportWithContext), varargs...) +} + +// GetGroup mocks base method +func (m *MockIAMAPI) GetGroup(arg0 *iam.GetGroupInput) (*iam.GetGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGroup", arg0) + ret0, _ := ret[0].(*iam.GetGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGroup indicates an expected call of GetGroup +func (mr *MockIAMAPIMockRecorder) GetGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroup", reflect.TypeOf((*MockIAMAPI)(nil).GetGroup), arg0) +} + +// GetGroupPages mocks base method +func (m *MockIAMAPI) GetGroupPages(arg0 *iam.GetGroupInput, arg1 func(*iam.GetGroupOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGroupPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetGroupPages indicates an expected call of GetGroupPages +func (mr *MockIAMAPIMockRecorder) GetGroupPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupPages", reflect.TypeOf((*MockIAMAPI)(nil).GetGroupPages), arg0, arg1) +} + +// GetGroupPagesWithContext mocks base method +func (m *MockIAMAPI) GetGroupPagesWithContext(arg0 context.Context, arg1 *iam.GetGroupInput, arg2 func(*iam.GetGroupOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetGroupPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetGroupPagesWithContext indicates an expected call of GetGroupPagesWithContext +func (mr *MockIAMAPIMockRecorder) GetGroupPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetGroupPagesWithContext), varargs...) +} + +// GetGroupPolicy mocks base method +func (m *MockIAMAPI) GetGroupPolicy(arg0 *iam.GetGroupPolicyInput) (*iam.GetGroupPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGroupPolicy", arg0) + ret0, _ := ret[0].(*iam.GetGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGroupPolicy indicates an expected call of GetGroupPolicy +func (mr *MockIAMAPIMockRecorder) GetGroupPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupPolicy", reflect.TypeOf((*MockIAMAPI)(nil).GetGroupPolicy), arg0) +} + +// GetGroupPolicyRequest mocks base method +func (m *MockIAMAPI) GetGroupPolicyRequest(arg0 *iam.GetGroupPolicyInput) (*request.Request, *iam.GetGroupPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGroupPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetGroupPolicyOutput) + return ret0, ret1 +} + +// GetGroupPolicyRequest indicates an expected call of GetGroupPolicyRequest +func (mr *MockIAMAPIMockRecorder) GetGroupPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetGroupPolicyRequest), arg0) +} + +// GetGroupPolicyWithContext mocks base method +func (m *MockIAMAPI) GetGroupPolicyWithContext(arg0 context.Context, arg1 *iam.GetGroupPolicyInput, arg2 ...request.Option) (*iam.GetGroupPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetGroupPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGroupPolicyWithContext indicates an expected call of GetGroupPolicyWithContext +func (mr *MockIAMAPIMockRecorder) GetGroupPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetGroupPolicyWithContext), varargs...) +} + +// GetGroupRequest mocks base method +func (m *MockIAMAPI) GetGroupRequest(arg0 *iam.GetGroupInput) (*request.Request, *iam.GetGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetGroupOutput) + return ret0, ret1 +} + +// GetGroupRequest indicates an expected call of GetGroupRequest +func (mr *MockIAMAPIMockRecorder) GetGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetGroupRequest), arg0) +} + +// GetGroupWithContext mocks base method +func (m *MockIAMAPI) GetGroupWithContext(arg0 context.Context, arg1 *iam.GetGroupInput, arg2 ...request.Option) (*iam.GetGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetGroupWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGroupWithContext indicates an expected call of GetGroupWithContext +func (mr *MockIAMAPIMockRecorder) GetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetGroupWithContext), varargs...) +} + +// GetInstanceProfile mocks base method +func (m *MockIAMAPI) GetInstanceProfile(arg0 *iam.GetInstanceProfileInput) (*iam.GetInstanceProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstanceProfile", arg0) + ret0, _ := ret[0].(*iam.GetInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstanceProfile indicates an expected call of GetInstanceProfile +func (mr *MockIAMAPIMockRecorder) GetInstanceProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceProfile", reflect.TypeOf((*MockIAMAPI)(nil).GetInstanceProfile), arg0) +} + +// GetInstanceProfileRequest mocks base method +func (m *MockIAMAPI) GetInstanceProfileRequest(arg0 *iam.GetInstanceProfileInput) (*request.Request, *iam.GetInstanceProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstanceProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetInstanceProfileOutput) + return ret0, ret1 +} + +// GetInstanceProfileRequest indicates an expected call of GetInstanceProfileRequest +func (mr *MockIAMAPIMockRecorder) GetInstanceProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetInstanceProfileRequest), arg0) +} + +// GetInstanceProfileWithContext mocks base method +func (m *MockIAMAPI) GetInstanceProfileWithContext(arg0 context.Context, arg1 *iam.GetInstanceProfileInput, arg2 ...request.Option) (*iam.GetInstanceProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetInstanceProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstanceProfileWithContext indicates an expected call of GetInstanceProfileWithContext +func (mr *MockIAMAPIMockRecorder) GetInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetInstanceProfileWithContext), varargs...) +} + +// GetLoginProfile mocks base method +func (m *MockIAMAPI) GetLoginProfile(arg0 *iam.GetLoginProfileInput) (*iam.GetLoginProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLoginProfile", arg0) + ret0, _ := ret[0].(*iam.GetLoginProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLoginProfile indicates an expected call of GetLoginProfile +func (mr *MockIAMAPIMockRecorder) GetLoginProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoginProfile", reflect.TypeOf((*MockIAMAPI)(nil).GetLoginProfile), arg0) +} + +// GetLoginProfileRequest mocks base method +func (m *MockIAMAPI) GetLoginProfileRequest(arg0 *iam.GetLoginProfileInput) (*request.Request, *iam.GetLoginProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLoginProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetLoginProfileOutput) + return ret0, ret1 +} + +// GetLoginProfileRequest indicates an expected call of GetLoginProfileRequest +func (mr *MockIAMAPIMockRecorder) GetLoginProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoginProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetLoginProfileRequest), arg0) +} + +// GetLoginProfileWithContext mocks base method +func (m *MockIAMAPI) GetLoginProfileWithContext(arg0 context.Context, arg1 *iam.GetLoginProfileInput, arg2 ...request.Option) (*iam.GetLoginProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetLoginProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetLoginProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLoginProfileWithContext indicates an expected call of GetLoginProfileWithContext +func (mr *MockIAMAPIMockRecorder) GetLoginProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoginProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetLoginProfileWithContext), varargs...) +} + +// GetOpenIDConnectProvider mocks base method +func (m *MockIAMAPI) GetOpenIDConnectProvider(arg0 *iam.GetOpenIDConnectProviderInput) (*iam.GetOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOpenIDConnectProvider", arg0) + ret0, _ := ret[0].(*iam.GetOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOpenIDConnectProvider indicates an expected call of GetOpenIDConnectProvider +func (mr *MockIAMAPIMockRecorder) GetOpenIDConnectProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenIDConnectProvider", reflect.TypeOf((*MockIAMAPI)(nil).GetOpenIDConnectProvider), arg0) +} + +// GetOpenIDConnectProviderRequest mocks base method +func (m *MockIAMAPI) GetOpenIDConnectProviderRequest(arg0 *iam.GetOpenIDConnectProviderInput) (*request.Request, *iam.GetOpenIDConnectProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOpenIDConnectProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetOpenIDConnectProviderOutput) + return ret0, ret1 +} + +// GetOpenIDConnectProviderRequest indicates an expected call of GetOpenIDConnectProviderRequest +func (mr *MockIAMAPIMockRecorder) GetOpenIDConnectProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenIDConnectProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetOpenIDConnectProviderRequest), arg0) +} + +// GetOpenIDConnectProviderWithContext mocks base method +func (m *MockIAMAPI) GetOpenIDConnectProviderWithContext(arg0 context.Context, arg1 *iam.GetOpenIDConnectProviderInput, arg2 ...request.Option) (*iam.GetOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOpenIDConnectProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOpenIDConnectProviderWithContext indicates an expected call of GetOpenIDConnectProviderWithContext +func (mr *MockIAMAPIMockRecorder) GetOpenIDConnectProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenIDConnectProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetOpenIDConnectProviderWithContext), varargs...) +} + +// GetOrganizationsAccessReport mocks base method +func (m *MockIAMAPI) GetOrganizationsAccessReport(arg0 *iam.GetOrganizationsAccessReportInput) (*iam.GetOrganizationsAccessReportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrganizationsAccessReport", arg0) + ret0, _ := ret[0].(*iam.GetOrganizationsAccessReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrganizationsAccessReport indicates an expected call of GetOrganizationsAccessReport +func (mr *MockIAMAPIMockRecorder) GetOrganizationsAccessReport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationsAccessReport", reflect.TypeOf((*MockIAMAPI)(nil).GetOrganizationsAccessReport), arg0) +} + +// GetOrganizationsAccessReportRequest mocks base method +func (m *MockIAMAPI) GetOrganizationsAccessReportRequest(arg0 *iam.GetOrganizationsAccessReportInput) (*request.Request, *iam.GetOrganizationsAccessReportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrganizationsAccessReportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetOrganizationsAccessReportOutput) + return ret0, ret1 +} + +// GetOrganizationsAccessReportRequest indicates an expected call of GetOrganizationsAccessReportRequest +func (mr *MockIAMAPIMockRecorder) GetOrganizationsAccessReportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationsAccessReportRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetOrganizationsAccessReportRequest), arg0) +} + +// GetOrganizationsAccessReportWithContext mocks base method +func (m *MockIAMAPI) GetOrganizationsAccessReportWithContext(arg0 context.Context, arg1 *iam.GetOrganizationsAccessReportInput, arg2 ...request.Option) (*iam.GetOrganizationsAccessReportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOrganizationsAccessReportWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetOrganizationsAccessReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrganizationsAccessReportWithContext indicates an expected call of GetOrganizationsAccessReportWithContext +func (mr *MockIAMAPIMockRecorder) GetOrganizationsAccessReportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationsAccessReportWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetOrganizationsAccessReportWithContext), varargs...) +} + +// GetPolicy mocks base method +func (m *MockIAMAPI) GetPolicy(arg0 *iam.GetPolicyInput) (*iam.GetPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPolicy", arg0) + ret0, _ := ret[0].(*iam.GetPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPolicy indicates an expected call of GetPolicy +func (mr *MockIAMAPIMockRecorder) GetPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicy", reflect.TypeOf((*MockIAMAPI)(nil).GetPolicy), arg0) +} + +// GetPolicyRequest mocks base method +func (m *MockIAMAPI) GetPolicyRequest(arg0 *iam.GetPolicyInput) (*request.Request, *iam.GetPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetPolicyOutput) + return ret0, ret1 +} + +// GetPolicyRequest indicates an expected call of GetPolicyRequest +func (mr *MockIAMAPIMockRecorder) GetPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetPolicyRequest), arg0) +} + +// GetPolicyVersion mocks base method +func (m *MockIAMAPI) GetPolicyVersion(arg0 *iam.GetPolicyVersionInput) (*iam.GetPolicyVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPolicyVersion", arg0) + ret0, _ := ret[0].(*iam.GetPolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPolicyVersion indicates an expected call of GetPolicyVersion +func (mr *MockIAMAPIMockRecorder) GetPolicyVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyVersion", reflect.TypeOf((*MockIAMAPI)(nil).GetPolicyVersion), arg0) +} + +// GetPolicyVersionRequest mocks base method +func (m *MockIAMAPI) GetPolicyVersionRequest(arg0 *iam.GetPolicyVersionInput) (*request.Request, *iam.GetPolicyVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPolicyVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetPolicyVersionOutput) + return ret0, ret1 +} + +// GetPolicyVersionRequest indicates an expected call of GetPolicyVersionRequest +func (mr *MockIAMAPIMockRecorder) GetPolicyVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyVersionRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetPolicyVersionRequest), arg0) +} + +// GetPolicyVersionWithContext mocks base method +func (m *MockIAMAPI) GetPolicyVersionWithContext(arg0 context.Context, arg1 *iam.GetPolicyVersionInput, arg2 ...request.Option) (*iam.GetPolicyVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPolicyVersionWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetPolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPolicyVersionWithContext indicates an expected call of GetPolicyVersionWithContext +func (mr *MockIAMAPIMockRecorder) GetPolicyVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyVersionWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetPolicyVersionWithContext), varargs...) +} + +// GetPolicyWithContext mocks base method +func (m *MockIAMAPI) GetPolicyWithContext(arg0 context.Context, arg1 *iam.GetPolicyInput, arg2 ...request.Option) (*iam.GetPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPolicyWithContext indicates an expected call of GetPolicyWithContext +func (mr *MockIAMAPIMockRecorder) GetPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetPolicyWithContext), varargs...) +} + +// GetRole mocks base method +func (m *MockIAMAPI) GetRole(arg0 *iam.GetRoleInput) (*iam.GetRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRole", arg0) + ret0, _ := ret[0].(*iam.GetRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRole indicates an expected call of GetRole +func (mr *MockIAMAPIMockRecorder) GetRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRole", reflect.TypeOf((*MockIAMAPI)(nil).GetRole), arg0) +} + +// GetRolePolicy mocks base method +func (m *MockIAMAPI) GetRolePolicy(arg0 *iam.GetRolePolicyInput) (*iam.GetRolePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRolePolicy", arg0) + ret0, _ := ret[0].(*iam.GetRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRolePolicy indicates an expected call of GetRolePolicy +func (mr *MockIAMAPIMockRecorder) GetRolePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolePolicy", reflect.TypeOf((*MockIAMAPI)(nil).GetRolePolicy), arg0) +} + +// GetRolePolicyRequest mocks base method +func (m *MockIAMAPI) GetRolePolicyRequest(arg0 *iam.GetRolePolicyInput) (*request.Request, *iam.GetRolePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRolePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetRolePolicyOutput) + return ret0, ret1 +} + +// GetRolePolicyRequest indicates an expected call of GetRolePolicyRequest +func (mr *MockIAMAPIMockRecorder) GetRolePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolePolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetRolePolicyRequest), arg0) +} + +// GetRolePolicyWithContext mocks base method +func (m *MockIAMAPI) GetRolePolicyWithContext(arg0 context.Context, arg1 *iam.GetRolePolicyInput, arg2 ...request.Option) (*iam.GetRolePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetRolePolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRolePolicyWithContext indicates an expected call of GetRolePolicyWithContext +func (mr *MockIAMAPIMockRecorder) GetRolePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolePolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetRolePolicyWithContext), varargs...) +} + +// GetRoleRequest mocks base method +func (m *MockIAMAPI) GetRoleRequest(arg0 *iam.GetRoleInput) (*request.Request, *iam.GetRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetRoleOutput) + return ret0, ret1 +} + +// GetRoleRequest indicates an expected call of GetRoleRequest +func (mr *MockIAMAPIMockRecorder) GetRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetRoleRequest), arg0) +} + +// GetRoleWithContext mocks base method +func (m *MockIAMAPI) GetRoleWithContext(arg0 context.Context, arg1 *iam.GetRoleInput, arg2 ...request.Option) (*iam.GetRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRoleWithContext indicates an expected call of GetRoleWithContext +func (mr *MockIAMAPIMockRecorder) GetRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetRoleWithContext), varargs...) +} + +// GetSAMLProvider mocks base method +func (m *MockIAMAPI) GetSAMLProvider(arg0 *iam.GetSAMLProviderInput) (*iam.GetSAMLProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSAMLProvider", arg0) + ret0, _ := ret[0].(*iam.GetSAMLProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSAMLProvider indicates an expected call of GetSAMLProvider +func (mr *MockIAMAPIMockRecorder) GetSAMLProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSAMLProvider", reflect.TypeOf((*MockIAMAPI)(nil).GetSAMLProvider), arg0) +} + +// GetSAMLProviderRequest mocks base method +func (m *MockIAMAPI) GetSAMLProviderRequest(arg0 *iam.GetSAMLProviderInput) (*request.Request, *iam.GetSAMLProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSAMLProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetSAMLProviderOutput) + return ret0, ret1 +} + +// GetSAMLProviderRequest indicates an expected call of GetSAMLProviderRequest +func (mr *MockIAMAPIMockRecorder) GetSAMLProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSAMLProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetSAMLProviderRequest), arg0) +} + +// GetSAMLProviderWithContext mocks base method +func (m *MockIAMAPI) GetSAMLProviderWithContext(arg0 context.Context, arg1 *iam.GetSAMLProviderInput, arg2 ...request.Option) (*iam.GetSAMLProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetSAMLProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetSAMLProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSAMLProviderWithContext indicates an expected call of GetSAMLProviderWithContext +func (mr *MockIAMAPIMockRecorder) GetSAMLProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSAMLProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetSAMLProviderWithContext), varargs...) +} + +// GetSSHPublicKey mocks base method +func (m *MockIAMAPI) GetSSHPublicKey(arg0 *iam.GetSSHPublicKeyInput) (*iam.GetSSHPublicKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSSHPublicKey", arg0) + ret0, _ := ret[0].(*iam.GetSSHPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSSHPublicKey indicates an expected call of GetSSHPublicKey +func (mr *MockIAMAPIMockRecorder) GetSSHPublicKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSSHPublicKey", reflect.TypeOf((*MockIAMAPI)(nil).GetSSHPublicKey), arg0) +} + +// GetSSHPublicKeyRequest mocks base method +func (m *MockIAMAPI) GetSSHPublicKeyRequest(arg0 *iam.GetSSHPublicKeyInput) (*request.Request, *iam.GetSSHPublicKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSSHPublicKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetSSHPublicKeyOutput) + return ret0, ret1 +} + +// GetSSHPublicKeyRequest indicates an expected call of GetSSHPublicKeyRequest +func (mr *MockIAMAPIMockRecorder) GetSSHPublicKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSSHPublicKeyRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetSSHPublicKeyRequest), arg0) +} + +// GetSSHPublicKeyWithContext mocks base method +func (m *MockIAMAPI) GetSSHPublicKeyWithContext(arg0 context.Context, arg1 *iam.GetSSHPublicKeyInput, arg2 ...request.Option) (*iam.GetSSHPublicKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetSSHPublicKeyWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetSSHPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSSHPublicKeyWithContext indicates an expected call of GetSSHPublicKeyWithContext +func (mr *MockIAMAPIMockRecorder) GetSSHPublicKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSSHPublicKeyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetSSHPublicKeyWithContext), varargs...) +} + +// GetServerCertificate mocks base method +func (m *MockIAMAPI) GetServerCertificate(arg0 *iam.GetServerCertificateInput) (*iam.GetServerCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetServerCertificate", arg0) + ret0, _ := ret[0].(*iam.GetServerCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetServerCertificate indicates an expected call of GetServerCertificate +func (mr *MockIAMAPIMockRecorder) GetServerCertificate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerCertificate", reflect.TypeOf((*MockIAMAPI)(nil).GetServerCertificate), arg0) +} + +// GetServerCertificateRequest mocks base method +func (m *MockIAMAPI) GetServerCertificateRequest(arg0 *iam.GetServerCertificateInput) (*request.Request, *iam.GetServerCertificateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetServerCertificateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetServerCertificateOutput) + return ret0, ret1 +} + +// GetServerCertificateRequest indicates an expected call of GetServerCertificateRequest +func (mr *MockIAMAPIMockRecorder) GetServerCertificateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerCertificateRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetServerCertificateRequest), arg0) +} + +// GetServerCertificateWithContext mocks base method +func (m *MockIAMAPI) GetServerCertificateWithContext(arg0 context.Context, arg1 *iam.GetServerCertificateInput, arg2 ...request.Option) (*iam.GetServerCertificateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetServerCertificateWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetServerCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetServerCertificateWithContext indicates an expected call of GetServerCertificateWithContext +func (mr *MockIAMAPIMockRecorder) GetServerCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerCertificateWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetServerCertificateWithContext), varargs...) +} + +// GetServiceLastAccessedDetails mocks base method +func (m *MockIAMAPI) GetServiceLastAccessedDetails(arg0 *iam.GetServiceLastAccessedDetailsInput) (*iam.GetServiceLastAccessedDetailsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetServiceLastAccessedDetails", arg0) + ret0, _ := ret[0].(*iam.GetServiceLastAccessedDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetServiceLastAccessedDetails indicates an expected call of GetServiceLastAccessedDetails +func (mr *MockIAMAPIMockRecorder) GetServiceLastAccessedDetails(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLastAccessedDetails", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLastAccessedDetails), arg0) +} + +// GetServiceLastAccessedDetailsRequest mocks base method +func (m *MockIAMAPI) GetServiceLastAccessedDetailsRequest(arg0 *iam.GetServiceLastAccessedDetailsInput) (*request.Request, *iam.GetServiceLastAccessedDetailsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetServiceLastAccessedDetailsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetServiceLastAccessedDetailsOutput) + return ret0, ret1 +} + +// GetServiceLastAccessedDetailsRequest indicates an expected call of GetServiceLastAccessedDetailsRequest +func (mr *MockIAMAPIMockRecorder) GetServiceLastAccessedDetailsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLastAccessedDetailsRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLastAccessedDetailsRequest), arg0) +} + +// GetServiceLastAccessedDetailsWithContext mocks base method +func (m *MockIAMAPI) GetServiceLastAccessedDetailsWithContext(arg0 context.Context, arg1 *iam.GetServiceLastAccessedDetailsInput, arg2 ...request.Option) (*iam.GetServiceLastAccessedDetailsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetServiceLastAccessedDetailsWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetServiceLastAccessedDetailsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetServiceLastAccessedDetailsWithContext indicates an expected call of GetServiceLastAccessedDetailsWithContext +func (mr *MockIAMAPIMockRecorder) GetServiceLastAccessedDetailsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLastAccessedDetailsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLastAccessedDetailsWithContext), varargs...) +} + +// GetServiceLastAccessedDetailsWithEntities mocks base method +func (m *MockIAMAPI) GetServiceLastAccessedDetailsWithEntities(arg0 *iam.GetServiceLastAccessedDetailsWithEntitiesInput) (*iam.GetServiceLastAccessedDetailsWithEntitiesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetServiceLastAccessedDetailsWithEntities", arg0) + ret0, _ := ret[0].(*iam.GetServiceLastAccessedDetailsWithEntitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetServiceLastAccessedDetailsWithEntities indicates an expected call of GetServiceLastAccessedDetailsWithEntities +func (mr *MockIAMAPIMockRecorder) GetServiceLastAccessedDetailsWithEntities(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLastAccessedDetailsWithEntities", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLastAccessedDetailsWithEntities), arg0) +} + +// GetServiceLastAccessedDetailsWithEntitiesRequest mocks base method +func (m *MockIAMAPI) GetServiceLastAccessedDetailsWithEntitiesRequest(arg0 *iam.GetServiceLastAccessedDetailsWithEntitiesInput) (*request.Request, *iam.GetServiceLastAccessedDetailsWithEntitiesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetServiceLastAccessedDetailsWithEntitiesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetServiceLastAccessedDetailsWithEntitiesOutput) + return ret0, ret1 +} + +// GetServiceLastAccessedDetailsWithEntitiesRequest indicates an expected call of GetServiceLastAccessedDetailsWithEntitiesRequest +func (mr *MockIAMAPIMockRecorder) GetServiceLastAccessedDetailsWithEntitiesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLastAccessedDetailsWithEntitiesRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLastAccessedDetailsWithEntitiesRequest), arg0) +} + +// GetServiceLastAccessedDetailsWithEntitiesWithContext mocks base method +func (m *MockIAMAPI) GetServiceLastAccessedDetailsWithEntitiesWithContext(arg0 context.Context, arg1 *iam.GetServiceLastAccessedDetailsWithEntitiesInput, arg2 ...request.Option) (*iam.GetServiceLastAccessedDetailsWithEntitiesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetServiceLastAccessedDetailsWithEntitiesWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetServiceLastAccessedDetailsWithEntitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetServiceLastAccessedDetailsWithEntitiesWithContext indicates an expected call of GetServiceLastAccessedDetailsWithEntitiesWithContext +func (mr *MockIAMAPIMockRecorder) GetServiceLastAccessedDetailsWithEntitiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLastAccessedDetailsWithEntitiesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLastAccessedDetailsWithEntitiesWithContext), varargs...) +} + +// GetServiceLinkedRoleDeletionStatus mocks base method +func (m *MockIAMAPI) GetServiceLinkedRoleDeletionStatus(arg0 *iam.GetServiceLinkedRoleDeletionStatusInput) (*iam.GetServiceLinkedRoleDeletionStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetServiceLinkedRoleDeletionStatus", arg0) + ret0, _ := ret[0].(*iam.GetServiceLinkedRoleDeletionStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetServiceLinkedRoleDeletionStatus indicates an expected call of GetServiceLinkedRoleDeletionStatus +func (mr *MockIAMAPIMockRecorder) GetServiceLinkedRoleDeletionStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLinkedRoleDeletionStatus", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLinkedRoleDeletionStatus), arg0) +} + +// GetServiceLinkedRoleDeletionStatusRequest mocks base method +func (m *MockIAMAPI) GetServiceLinkedRoleDeletionStatusRequest(arg0 *iam.GetServiceLinkedRoleDeletionStatusInput) (*request.Request, *iam.GetServiceLinkedRoleDeletionStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetServiceLinkedRoleDeletionStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetServiceLinkedRoleDeletionStatusOutput) + return ret0, ret1 +} + +// GetServiceLinkedRoleDeletionStatusRequest indicates an expected call of GetServiceLinkedRoleDeletionStatusRequest +func (mr *MockIAMAPIMockRecorder) GetServiceLinkedRoleDeletionStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLinkedRoleDeletionStatusRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLinkedRoleDeletionStatusRequest), arg0) +} + +// GetServiceLinkedRoleDeletionStatusWithContext mocks base method +func (m *MockIAMAPI) GetServiceLinkedRoleDeletionStatusWithContext(arg0 context.Context, arg1 *iam.GetServiceLinkedRoleDeletionStatusInput, arg2 ...request.Option) (*iam.GetServiceLinkedRoleDeletionStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetServiceLinkedRoleDeletionStatusWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetServiceLinkedRoleDeletionStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetServiceLinkedRoleDeletionStatusWithContext indicates an expected call of GetServiceLinkedRoleDeletionStatusWithContext +func (mr *MockIAMAPIMockRecorder) GetServiceLinkedRoleDeletionStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceLinkedRoleDeletionStatusWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetServiceLinkedRoleDeletionStatusWithContext), varargs...) +} + +// GetUser mocks base method +func (m *MockIAMAPI) GetUser(arg0 *iam.GetUserInput) (*iam.GetUserOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUser", arg0) + ret0, _ := ret[0].(*iam.GetUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUser indicates an expected call of GetUser +func (mr *MockIAMAPIMockRecorder) GetUser(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockIAMAPI)(nil).GetUser), arg0) +} + +// GetUserPolicy mocks base method +func (m *MockIAMAPI) GetUserPolicy(arg0 *iam.GetUserPolicyInput) (*iam.GetUserPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserPolicy", arg0) + ret0, _ := ret[0].(*iam.GetUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserPolicy indicates an expected call of GetUserPolicy +func (mr *MockIAMAPIMockRecorder) GetUserPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserPolicy", reflect.TypeOf((*MockIAMAPI)(nil).GetUserPolicy), arg0) +} + +// GetUserPolicyRequest mocks base method +func (m *MockIAMAPI) GetUserPolicyRequest(arg0 *iam.GetUserPolicyInput) (*request.Request, *iam.GetUserPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetUserPolicyOutput) + return ret0, ret1 +} + +// GetUserPolicyRequest indicates an expected call of GetUserPolicyRequest +func (mr *MockIAMAPIMockRecorder) GetUserPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetUserPolicyRequest), arg0) +} + +// GetUserPolicyWithContext mocks base method +func (m *MockIAMAPI) GetUserPolicyWithContext(arg0 context.Context, arg1 *iam.GetUserPolicyInput, arg2 ...request.Option) (*iam.GetUserPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserPolicyWithContext indicates an expected call of GetUserPolicyWithContext +func (mr *MockIAMAPIMockRecorder) GetUserPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetUserPolicyWithContext), varargs...) +} + +// GetUserRequest mocks base method +func (m *MockIAMAPI) GetUserRequest(arg0 *iam.GetUserInput) (*request.Request, *iam.GetUserOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetUserRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.GetUserOutput) + return ret0, ret1 +} + +// GetUserRequest indicates an expected call of GetUserRequest +func (mr *MockIAMAPIMockRecorder) GetUserRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserRequest", reflect.TypeOf((*MockIAMAPI)(nil).GetUserRequest), arg0) +} + +// GetUserWithContext mocks base method +func (m *MockIAMAPI) GetUserWithContext(arg0 context.Context, arg1 *iam.GetUserInput, arg2 ...request.Option) (*iam.GetUserOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserWithContext", varargs...) + ret0, _ := ret[0].(*iam.GetUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserWithContext indicates an expected call of GetUserWithContext +func (mr *MockIAMAPIMockRecorder) GetUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserWithContext", reflect.TypeOf((*MockIAMAPI)(nil).GetUserWithContext), varargs...) +} + +// ListAccessKeys mocks base method +func (m *MockIAMAPI) ListAccessKeys(arg0 *iam.ListAccessKeysInput) (*iam.ListAccessKeysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAccessKeys", arg0) + ret0, _ := ret[0].(*iam.ListAccessKeysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAccessKeys indicates an expected call of ListAccessKeys +func (mr *MockIAMAPIMockRecorder) ListAccessKeys(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccessKeys", reflect.TypeOf((*MockIAMAPI)(nil).ListAccessKeys), arg0) +} + +// ListAccessKeysPages mocks base method +func (m *MockIAMAPI) ListAccessKeysPages(arg0 *iam.ListAccessKeysInput, arg1 func(*iam.ListAccessKeysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAccessKeysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAccessKeysPages indicates an expected call of ListAccessKeysPages +func (mr *MockIAMAPIMockRecorder) ListAccessKeysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccessKeysPages", reflect.TypeOf((*MockIAMAPI)(nil).ListAccessKeysPages), arg0, arg1) +} + +// ListAccessKeysPagesWithContext mocks base method +func (m *MockIAMAPI) ListAccessKeysPagesWithContext(arg0 context.Context, arg1 *iam.ListAccessKeysInput, arg2 func(*iam.ListAccessKeysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAccessKeysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAccessKeysPagesWithContext indicates an expected call of ListAccessKeysPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListAccessKeysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccessKeysPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAccessKeysPagesWithContext), varargs...) +} + +// ListAccessKeysRequest mocks base method +func (m *MockIAMAPI) ListAccessKeysRequest(arg0 *iam.ListAccessKeysInput) (*request.Request, *iam.ListAccessKeysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAccessKeysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListAccessKeysOutput) + return ret0, ret1 +} + +// ListAccessKeysRequest indicates an expected call of ListAccessKeysRequest +func (mr *MockIAMAPIMockRecorder) ListAccessKeysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccessKeysRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListAccessKeysRequest), arg0) +} + +// ListAccessKeysWithContext mocks base method +func (m *MockIAMAPI) ListAccessKeysWithContext(arg0 context.Context, arg1 *iam.ListAccessKeysInput, arg2 ...request.Option) (*iam.ListAccessKeysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAccessKeysWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListAccessKeysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAccessKeysWithContext indicates an expected call of ListAccessKeysWithContext +func (mr *MockIAMAPIMockRecorder) ListAccessKeysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccessKeysWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAccessKeysWithContext), varargs...) +} + +// ListAccountAliases mocks base method +func (m *MockIAMAPI) ListAccountAliases(arg0 *iam.ListAccountAliasesInput) (*iam.ListAccountAliasesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAccountAliases", arg0) + ret0, _ := ret[0].(*iam.ListAccountAliasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAccountAliases indicates an expected call of ListAccountAliases +func (mr *MockIAMAPIMockRecorder) ListAccountAliases(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountAliases", reflect.TypeOf((*MockIAMAPI)(nil).ListAccountAliases), arg0) +} + +// ListAccountAliasesPages mocks base method +func (m *MockIAMAPI) ListAccountAliasesPages(arg0 *iam.ListAccountAliasesInput, arg1 func(*iam.ListAccountAliasesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAccountAliasesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAccountAliasesPages indicates an expected call of ListAccountAliasesPages +func (mr *MockIAMAPIMockRecorder) ListAccountAliasesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountAliasesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListAccountAliasesPages), arg0, arg1) +} + +// ListAccountAliasesPagesWithContext mocks base method +func (m *MockIAMAPI) ListAccountAliasesPagesWithContext(arg0 context.Context, arg1 *iam.ListAccountAliasesInput, arg2 func(*iam.ListAccountAliasesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAccountAliasesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAccountAliasesPagesWithContext indicates an expected call of ListAccountAliasesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListAccountAliasesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountAliasesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAccountAliasesPagesWithContext), varargs...) +} + +// ListAccountAliasesRequest mocks base method +func (m *MockIAMAPI) ListAccountAliasesRequest(arg0 *iam.ListAccountAliasesInput) (*request.Request, *iam.ListAccountAliasesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAccountAliasesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListAccountAliasesOutput) + return ret0, ret1 +} + +// ListAccountAliasesRequest indicates an expected call of ListAccountAliasesRequest +func (mr *MockIAMAPIMockRecorder) ListAccountAliasesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountAliasesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListAccountAliasesRequest), arg0) +} + +// ListAccountAliasesWithContext mocks base method +func (m *MockIAMAPI) ListAccountAliasesWithContext(arg0 context.Context, arg1 *iam.ListAccountAliasesInput, arg2 ...request.Option) (*iam.ListAccountAliasesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAccountAliasesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListAccountAliasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAccountAliasesWithContext indicates an expected call of ListAccountAliasesWithContext +func (mr *MockIAMAPIMockRecorder) ListAccountAliasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountAliasesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAccountAliasesWithContext), varargs...) +} + +// ListAttachedGroupPolicies mocks base method +func (m *MockIAMAPI) ListAttachedGroupPolicies(arg0 *iam.ListAttachedGroupPoliciesInput) (*iam.ListAttachedGroupPoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedGroupPolicies", arg0) + ret0, _ := ret[0].(*iam.ListAttachedGroupPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAttachedGroupPolicies indicates an expected call of ListAttachedGroupPolicies +func (mr *MockIAMAPIMockRecorder) ListAttachedGroupPolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedGroupPolicies", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedGroupPolicies), arg0) +} + +// ListAttachedGroupPoliciesPages mocks base method +func (m *MockIAMAPI) ListAttachedGroupPoliciesPages(arg0 *iam.ListAttachedGroupPoliciesInput, arg1 func(*iam.ListAttachedGroupPoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedGroupPoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAttachedGroupPoliciesPages indicates an expected call of ListAttachedGroupPoliciesPages +func (mr *MockIAMAPIMockRecorder) ListAttachedGroupPoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedGroupPoliciesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedGroupPoliciesPages), arg0, arg1) +} + +// ListAttachedGroupPoliciesPagesWithContext mocks base method +func (m *MockIAMAPI) ListAttachedGroupPoliciesPagesWithContext(arg0 context.Context, arg1 *iam.ListAttachedGroupPoliciesInput, arg2 func(*iam.ListAttachedGroupPoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAttachedGroupPoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAttachedGroupPoliciesPagesWithContext indicates an expected call of ListAttachedGroupPoliciesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListAttachedGroupPoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedGroupPoliciesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedGroupPoliciesPagesWithContext), varargs...) +} + +// ListAttachedGroupPoliciesRequest mocks base method +func (m *MockIAMAPI) ListAttachedGroupPoliciesRequest(arg0 *iam.ListAttachedGroupPoliciesInput) (*request.Request, *iam.ListAttachedGroupPoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedGroupPoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListAttachedGroupPoliciesOutput) + return ret0, ret1 +} + +// ListAttachedGroupPoliciesRequest indicates an expected call of ListAttachedGroupPoliciesRequest +func (mr *MockIAMAPIMockRecorder) ListAttachedGroupPoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedGroupPoliciesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedGroupPoliciesRequest), arg0) +} + +// ListAttachedGroupPoliciesWithContext mocks base method +func (m *MockIAMAPI) ListAttachedGroupPoliciesWithContext(arg0 context.Context, arg1 *iam.ListAttachedGroupPoliciesInput, arg2 ...request.Option) (*iam.ListAttachedGroupPoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAttachedGroupPoliciesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListAttachedGroupPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAttachedGroupPoliciesWithContext indicates an expected call of ListAttachedGroupPoliciesWithContext +func (mr *MockIAMAPIMockRecorder) ListAttachedGroupPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedGroupPoliciesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedGroupPoliciesWithContext), varargs...) +} + +// ListAttachedRolePolicies mocks base method +func (m *MockIAMAPI) ListAttachedRolePolicies(arg0 *iam.ListAttachedRolePoliciesInput) (*iam.ListAttachedRolePoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedRolePolicies", arg0) + ret0, _ := ret[0].(*iam.ListAttachedRolePoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAttachedRolePolicies indicates an expected call of ListAttachedRolePolicies +func (mr *MockIAMAPIMockRecorder) ListAttachedRolePolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedRolePolicies", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedRolePolicies), arg0) +} + +// ListAttachedRolePoliciesPages mocks base method +func (m *MockIAMAPI) ListAttachedRolePoliciesPages(arg0 *iam.ListAttachedRolePoliciesInput, arg1 func(*iam.ListAttachedRolePoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedRolePoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAttachedRolePoliciesPages indicates an expected call of ListAttachedRolePoliciesPages +func (mr *MockIAMAPIMockRecorder) ListAttachedRolePoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedRolePoliciesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedRolePoliciesPages), arg0, arg1) +} + +// ListAttachedRolePoliciesPagesWithContext mocks base method +func (m *MockIAMAPI) ListAttachedRolePoliciesPagesWithContext(arg0 context.Context, arg1 *iam.ListAttachedRolePoliciesInput, arg2 func(*iam.ListAttachedRolePoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAttachedRolePoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAttachedRolePoliciesPagesWithContext indicates an expected call of ListAttachedRolePoliciesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListAttachedRolePoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedRolePoliciesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedRolePoliciesPagesWithContext), varargs...) +} + +// ListAttachedRolePoliciesRequest mocks base method +func (m *MockIAMAPI) ListAttachedRolePoliciesRequest(arg0 *iam.ListAttachedRolePoliciesInput) (*request.Request, *iam.ListAttachedRolePoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedRolePoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListAttachedRolePoliciesOutput) + return ret0, ret1 +} + +// ListAttachedRolePoliciesRequest indicates an expected call of ListAttachedRolePoliciesRequest +func (mr *MockIAMAPIMockRecorder) ListAttachedRolePoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedRolePoliciesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedRolePoliciesRequest), arg0) +} + +// ListAttachedRolePoliciesWithContext mocks base method +func (m *MockIAMAPI) ListAttachedRolePoliciesWithContext(arg0 context.Context, arg1 *iam.ListAttachedRolePoliciesInput, arg2 ...request.Option) (*iam.ListAttachedRolePoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAttachedRolePoliciesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListAttachedRolePoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAttachedRolePoliciesWithContext indicates an expected call of ListAttachedRolePoliciesWithContext +func (mr *MockIAMAPIMockRecorder) ListAttachedRolePoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedRolePoliciesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedRolePoliciesWithContext), varargs...) +} + +// ListAttachedUserPolicies mocks base method +func (m *MockIAMAPI) ListAttachedUserPolicies(arg0 *iam.ListAttachedUserPoliciesInput) (*iam.ListAttachedUserPoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedUserPolicies", arg0) + ret0, _ := ret[0].(*iam.ListAttachedUserPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAttachedUserPolicies indicates an expected call of ListAttachedUserPolicies +func (mr *MockIAMAPIMockRecorder) ListAttachedUserPolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedUserPolicies", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedUserPolicies), arg0) +} + +// ListAttachedUserPoliciesPages mocks base method +func (m *MockIAMAPI) ListAttachedUserPoliciesPages(arg0 *iam.ListAttachedUserPoliciesInput, arg1 func(*iam.ListAttachedUserPoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedUserPoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAttachedUserPoliciesPages indicates an expected call of ListAttachedUserPoliciesPages +func (mr *MockIAMAPIMockRecorder) ListAttachedUserPoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedUserPoliciesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedUserPoliciesPages), arg0, arg1) +} + +// ListAttachedUserPoliciesPagesWithContext mocks base method +func (m *MockIAMAPI) ListAttachedUserPoliciesPagesWithContext(arg0 context.Context, arg1 *iam.ListAttachedUserPoliciesInput, arg2 func(*iam.ListAttachedUserPoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAttachedUserPoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAttachedUserPoliciesPagesWithContext indicates an expected call of ListAttachedUserPoliciesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListAttachedUserPoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedUserPoliciesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedUserPoliciesPagesWithContext), varargs...) +} + +// ListAttachedUserPoliciesRequest mocks base method +func (m *MockIAMAPI) ListAttachedUserPoliciesRequest(arg0 *iam.ListAttachedUserPoliciesInput) (*request.Request, *iam.ListAttachedUserPoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAttachedUserPoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListAttachedUserPoliciesOutput) + return ret0, ret1 +} + +// ListAttachedUserPoliciesRequest indicates an expected call of ListAttachedUserPoliciesRequest +func (mr *MockIAMAPIMockRecorder) ListAttachedUserPoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedUserPoliciesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedUserPoliciesRequest), arg0) +} + +// ListAttachedUserPoliciesWithContext mocks base method +func (m *MockIAMAPI) ListAttachedUserPoliciesWithContext(arg0 context.Context, arg1 *iam.ListAttachedUserPoliciesInput, arg2 ...request.Option) (*iam.ListAttachedUserPoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAttachedUserPoliciesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListAttachedUserPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAttachedUserPoliciesWithContext indicates an expected call of ListAttachedUserPoliciesWithContext +func (mr *MockIAMAPIMockRecorder) ListAttachedUserPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttachedUserPoliciesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListAttachedUserPoliciesWithContext), varargs...) +} + +// ListEntitiesForPolicy mocks base method +func (m *MockIAMAPI) ListEntitiesForPolicy(arg0 *iam.ListEntitiesForPolicyInput) (*iam.ListEntitiesForPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListEntitiesForPolicy", arg0) + ret0, _ := ret[0].(*iam.ListEntitiesForPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListEntitiesForPolicy indicates an expected call of ListEntitiesForPolicy +func (mr *MockIAMAPIMockRecorder) ListEntitiesForPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEntitiesForPolicy", reflect.TypeOf((*MockIAMAPI)(nil).ListEntitiesForPolicy), arg0) +} + +// ListEntitiesForPolicyPages mocks base method +func (m *MockIAMAPI) ListEntitiesForPolicyPages(arg0 *iam.ListEntitiesForPolicyInput, arg1 func(*iam.ListEntitiesForPolicyOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListEntitiesForPolicyPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListEntitiesForPolicyPages indicates an expected call of ListEntitiesForPolicyPages +func (mr *MockIAMAPIMockRecorder) ListEntitiesForPolicyPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEntitiesForPolicyPages", reflect.TypeOf((*MockIAMAPI)(nil).ListEntitiesForPolicyPages), arg0, arg1) +} + +// ListEntitiesForPolicyPagesWithContext mocks base method +func (m *MockIAMAPI) ListEntitiesForPolicyPagesWithContext(arg0 context.Context, arg1 *iam.ListEntitiesForPolicyInput, arg2 func(*iam.ListEntitiesForPolicyOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListEntitiesForPolicyPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListEntitiesForPolicyPagesWithContext indicates an expected call of ListEntitiesForPolicyPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListEntitiesForPolicyPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEntitiesForPolicyPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListEntitiesForPolicyPagesWithContext), varargs...) +} + +// ListEntitiesForPolicyRequest mocks base method +func (m *MockIAMAPI) ListEntitiesForPolicyRequest(arg0 *iam.ListEntitiesForPolicyInput) (*request.Request, *iam.ListEntitiesForPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListEntitiesForPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListEntitiesForPolicyOutput) + return ret0, ret1 +} + +// ListEntitiesForPolicyRequest indicates an expected call of ListEntitiesForPolicyRequest +func (mr *MockIAMAPIMockRecorder) ListEntitiesForPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEntitiesForPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListEntitiesForPolicyRequest), arg0) +} + +// ListEntitiesForPolicyWithContext mocks base method +func (m *MockIAMAPI) ListEntitiesForPolicyWithContext(arg0 context.Context, arg1 *iam.ListEntitiesForPolicyInput, arg2 ...request.Option) (*iam.ListEntitiesForPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListEntitiesForPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListEntitiesForPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListEntitiesForPolicyWithContext indicates an expected call of ListEntitiesForPolicyWithContext +func (mr *MockIAMAPIMockRecorder) ListEntitiesForPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEntitiesForPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListEntitiesForPolicyWithContext), varargs...) +} + +// ListGroupPolicies mocks base method +func (m *MockIAMAPI) ListGroupPolicies(arg0 *iam.ListGroupPoliciesInput) (*iam.ListGroupPoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroupPolicies", arg0) + ret0, _ := ret[0].(*iam.ListGroupPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGroupPolicies indicates an expected call of ListGroupPolicies +func (mr *MockIAMAPIMockRecorder) ListGroupPolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupPolicies", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupPolicies), arg0) +} + +// ListGroupPoliciesPages mocks base method +func (m *MockIAMAPI) ListGroupPoliciesPages(arg0 *iam.ListGroupPoliciesInput, arg1 func(*iam.ListGroupPoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroupPoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGroupPoliciesPages indicates an expected call of ListGroupPoliciesPages +func (mr *MockIAMAPIMockRecorder) ListGroupPoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupPoliciesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupPoliciesPages), arg0, arg1) +} + +// ListGroupPoliciesPagesWithContext mocks base method +func (m *MockIAMAPI) ListGroupPoliciesPagesWithContext(arg0 context.Context, arg1 *iam.ListGroupPoliciesInput, arg2 func(*iam.ListGroupPoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGroupPoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGroupPoliciesPagesWithContext indicates an expected call of ListGroupPoliciesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListGroupPoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupPoliciesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupPoliciesPagesWithContext), varargs...) +} + +// ListGroupPoliciesRequest mocks base method +func (m *MockIAMAPI) ListGroupPoliciesRequest(arg0 *iam.ListGroupPoliciesInput) (*request.Request, *iam.ListGroupPoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroupPoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListGroupPoliciesOutput) + return ret0, ret1 +} + +// ListGroupPoliciesRequest indicates an expected call of ListGroupPoliciesRequest +func (mr *MockIAMAPIMockRecorder) ListGroupPoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupPoliciesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupPoliciesRequest), arg0) +} + +// ListGroupPoliciesWithContext mocks base method +func (m *MockIAMAPI) ListGroupPoliciesWithContext(arg0 context.Context, arg1 *iam.ListGroupPoliciesInput, arg2 ...request.Option) (*iam.ListGroupPoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGroupPoliciesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListGroupPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGroupPoliciesWithContext indicates an expected call of ListGroupPoliciesWithContext +func (mr *MockIAMAPIMockRecorder) ListGroupPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupPoliciesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupPoliciesWithContext), varargs...) +} + +// ListGroups mocks base method +func (m *MockIAMAPI) ListGroups(arg0 *iam.ListGroupsInput) (*iam.ListGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroups", arg0) + ret0, _ := ret[0].(*iam.ListGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGroups indicates an expected call of ListGroups +func (mr *MockIAMAPIMockRecorder) ListGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroups", reflect.TypeOf((*MockIAMAPI)(nil).ListGroups), arg0) +} + +// ListGroupsForUser mocks base method +func (m *MockIAMAPI) ListGroupsForUser(arg0 *iam.ListGroupsForUserInput) (*iam.ListGroupsForUserOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroupsForUser", arg0) + ret0, _ := ret[0].(*iam.ListGroupsForUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGroupsForUser indicates an expected call of ListGroupsForUser +func (mr *MockIAMAPIMockRecorder) ListGroupsForUser(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsForUser", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsForUser), arg0) +} + +// ListGroupsForUserPages mocks base method +func (m *MockIAMAPI) ListGroupsForUserPages(arg0 *iam.ListGroupsForUserInput, arg1 func(*iam.ListGroupsForUserOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroupsForUserPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGroupsForUserPages indicates an expected call of ListGroupsForUserPages +func (mr *MockIAMAPIMockRecorder) ListGroupsForUserPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsForUserPages", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsForUserPages), arg0, arg1) +} + +// ListGroupsForUserPagesWithContext mocks base method +func (m *MockIAMAPI) ListGroupsForUserPagesWithContext(arg0 context.Context, arg1 *iam.ListGroupsForUserInput, arg2 func(*iam.ListGroupsForUserOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGroupsForUserPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGroupsForUserPagesWithContext indicates an expected call of ListGroupsForUserPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListGroupsForUserPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsForUserPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsForUserPagesWithContext), varargs...) +} + +// ListGroupsForUserRequest mocks base method +func (m *MockIAMAPI) ListGroupsForUserRequest(arg0 *iam.ListGroupsForUserInput) (*request.Request, *iam.ListGroupsForUserOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroupsForUserRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListGroupsForUserOutput) + return ret0, ret1 +} + +// ListGroupsForUserRequest indicates an expected call of ListGroupsForUserRequest +func (mr *MockIAMAPIMockRecorder) ListGroupsForUserRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsForUserRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsForUserRequest), arg0) +} + +// ListGroupsForUserWithContext mocks base method +func (m *MockIAMAPI) ListGroupsForUserWithContext(arg0 context.Context, arg1 *iam.ListGroupsForUserInput, arg2 ...request.Option) (*iam.ListGroupsForUserOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGroupsForUserWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListGroupsForUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGroupsForUserWithContext indicates an expected call of ListGroupsForUserWithContext +func (mr *MockIAMAPIMockRecorder) ListGroupsForUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsForUserWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsForUserWithContext), varargs...) +} + +// ListGroupsPages mocks base method +func (m *MockIAMAPI) ListGroupsPages(arg0 *iam.ListGroupsInput, arg1 func(*iam.ListGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGroupsPages indicates an expected call of ListGroupsPages +func (mr *MockIAMAPIMockRecorder) ListGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsPages", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsPages), arg0, arg1) +} + +// ListGroupsPagesWithContext mocks base method +func (m *MockIAMAPI) ListGroupsPagesWithContext(arg0 context.Context, arg1 *iam.ListGroupsInput, arg2 func(*iam.ListGroupsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGroupsPagesWithContext indicates an expected call of ListGroupsPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsPagesWithContext), varargs...) +} + +// ListGroupsRequest mocks base method +func (m *MockIAMAPI) ListGroupsRequest(arg0 *iam.ListGroupsInput) (*request.Request, *iam.ListGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListGroupsOutput) + return ret0, ret1 +} + +// ListGroupsRequest indicates an expected call of ListGroupsRequest +func (mr *MockIAMAPIMockRecorder) ListGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsRequest), arg0) +} + +// ListGroupsWithContext mocks base method +func (m *MockIAMAPI) ListGroupsWithContext(arg0 context.Context, arg1 *iam.ListGroupsInput, arg2 ...request.Option) (*iam.ListGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGroupsWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGroupsWithContext indicates an expected call of ListGroupsWithContext +func (mr *MockIAMAPIMockRecorder) ListGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListGroupsWithContext), varargs...) +} + +// ListInstanceProfiles mocks base method +func (m *MockIAMAPI) ListInstanceProfiles(arg0 *iam.ListInstanceProfilesInput) (*iam.ListInstanceProfilesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListInstanceProfiles", arg0) + ret0, _ := ret[0].(*iam.ListInstanceProfilesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListInstanceProfiles indicates an expected call of ListInstanceProfiles +func (mr *MockIAMAPIMockRecorder) ListInstanceProfiles(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfiles", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfiles), arg0) +} + +// ListInstanceProfilesForRole mocks base method +func (m *MockIAMAPI) ListInstanceProfilesForRole(arg0 *iam.ListInstanceProfilesForRoleInput) (*iam.ListInstanceProfilesForRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListInstanceProfilesForRole", arg0) + ret0, _ := ret[0].(*iam.ListInstanceProfilesForRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListInstanceProfilesForRole indicates an expected call of ListInstanceProfilesForRole +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesForRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesForRole", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesForRole), arg0) +} + +// ListInstanceProfilesForRolePages mocks base method +func (m *MockIAMAPI) ListInstanceProfilesForRolePages(arg0 *iam.ListInstanceProfilesForRoleInput, arg1 func(*iam.ListInstanceProfilesForRoleOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListInstanceProfilesForRolePages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListInstanceProfilesForRolePages indicates an expected call of ListInstanceProfilesForRolePages +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesForRolePages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesForRolePages", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesForRolePages), arg0, arg1) +} + +// ListInstanceProfilesForRolePagesWithContext mocks base method +func (m *MockIAMAPI) ListInstanceProfilesForRolePagesWithContext(arg0 context.Context, arg1 *iam.ListInstanceProfilesForRoleInput, arg2 func(*iam.ListInstanceProfilesForRoleOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListInstanceProfilesForRolePagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListInstanceProfilesForRolePagesWithContext indicates an expected call of ListInstanceProfilesForRolePagesWithContext +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesForRolePagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesForRolePagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesForRolePagesWithContext), varargs...) +} + +// ListInstanceProfilesForRoleRequest mocks base method +func (m *MockIAMAPI) ListInstanceProfilesForRoleRequest(arg0 *iam.ListInstanceProfilesForRoleInput) (*request.Request, *iam.ListInstanceProfilesForRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListInstanceProfilesForRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListInstanceProfilesForRoleOutput) + return ret0, ret1 +} + +// ListInstanceProfilesForRoleRequest indicates an expected call of ListInstanceProfilesForRoleRequest +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesForRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesForRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesForRoleRequest), arg0) +} + +// ListInstanceProfilesForRoleWithContext mocks base method +func (m *MockIAMAPI) ListInstanceProfilesForRoleWithContext(arg0 context.Context, arg1 *iam.ListInstanceProfilesForRoleInput, arg2 ...request.Option) (*iam.ListInstanceProfilesForRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListInstanceProfilesForRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListInstanceProfilesForRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListInstanceProfilesForRoleWithContext indicates an expected call of ListInstanceProfilesForRoleWithContext +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesForRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesForRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesForRoleWithContext), varargs...) +} + +// ListInstanceProfilesPages mocks base method +func (m *MockIAMAPI) ListInstanceProfilesPages(arg0 *iam.ListInstanceProfilesInput, arg1 func(*iam.ListInstanceProfilesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListInstanceProfilesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListInstanceProfilesPages indicates an expected call of ListInstanceProfilesPages +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesPages), arg0, arg1) +} + +// ListInstanceProfilesPagesWithContext mocks base method +func (m *MockIAMAPI) ListInstanceProfilesPagesWithContext(arg0 context.Context, arg1 *iam.ListInstanceProfilesInput, arg2 func(*iam.ListInstanceProfilesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListInstanceProfilesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListInstanceProfilesPagesWithContext indicates an expected call of ListInstanceProfilesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesPagesWithContext), varargs...) +} + +// ListInstanceProfilesRequest mocks base method +func (m *MockIAMAPI) ListInstanceProfilesRequest(arg0 *iam.ListInstanceProfilesInput) (*request.Request, *iam.ListInstanceProfilesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListInstanceProfilesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListInstanceProfilesOutput) + return ret0, ret1 +} + +// ListInstanceProfilesRequest indicates an expected call of ListInstanceProfilesRequest +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesRequest), arg0) +} + +// ListInstanceProfilesWithContext mocks base method +func (m *MockIAMAPI) ListInstanceProfilesWithContext(arg0 context.Context, arg1 *iam.ListInstanceProfilesInput, arg2 ...request.Option) (*iam.ListInstanceProfilesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListInstanceProfilesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListInstanceProfilesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListInstanceProfilesWithContext indicates an expected call of ListInstanceProfilesWithContext +func (mr *MockIAMAPIMockRecorder) ListInstanceProfilesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInstanceProfilesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListInstanceProfilesWithContext), varargs...) +} + +// ListMFADevices mocks base method +func (m *MockIAMAPI) ListMFADevices(arg0 *iam.ListMFADevicesInput) (*iam.ListMFADevicesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListMFADevices", arg0) + ret0, _ := ret[0].(*iam.ListMFADevicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListMFADevices indicates an expected call of ListMFADevices +func (mr *MockIAMAPIMockRecorder) ListMFADevices(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMFADevices", reflect.TypeOf((*MockIAMAPI)(nil).ListMFADevices), arg0) +} + +// ListMFADevicesPages mocks base method +func (m *MockIAMAPI) ListMFADevicesPages(arg0 *iam.ListMFADevicesInput, arg1 func(*iam.ListMFADevicesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListMFADevicesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListMFADevicesPages indicates an expected call of ListMFADevicesPages +func (mr *MockIAMAPIMockRecorder) ListMFADevicesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMFADevicesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListMFADevicesPages), arg0, arg1) +} + +// ListMFADevicesPagesWithContext mocks base method +func (m *MockIAMAPI) ListMFADevicesPagesWithContext(arg0 context.Context, arg1 *iam.ListMFADevicesInput, arg2 func(*iam.ListMFADevicesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListMFADevicesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListMFADevicesPagesWithContext indicates an expected call of ListMFADevicesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListMFADevicesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMFADevicesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListMFADevicesPagesWithContext), varargs...) +} + +// ListMFADevicesRequest mocks base method +func (m *MockIAMAPI) ListMFADevicesRequest(arg0 *iam.ListMFADevicesInput) (*request.Request, *iam.ListMFADevicesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListMFADevicesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListMFADevicesOutput) + return ret0, ret1 +} + +// ListMFADevicesRequest indicates an expected call of ListMFADevicesRequest +func (mr *MockIAMAPIMockRecorder) ListMFADevicesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMFADevicesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListMFADevicesRequest), arg0) +} + +// ListMFADevicesWithContext mocks base method +func (m *MockIAMAPI) ListMFADevicesWithContext(arg0 context.Context, arg1 *iam.ListMFADevicesInput, arg2 ...request.Option) (*iam.ListMFADevicesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListMFADevicesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListMFADevicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListMFADevicesWithContext indicates an expected call of ListMFADevicesWithContext +func (mr *MockIAMAPIMockRecorder) ListMFADevicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMFADevicesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListMFADevicesWithContext), varargs...) +} + +// ListOpenIDConnectProviders mocks base method +func (m *MockIAMAPI) ListOpenIDConnectProviders(arg0 *iam.ListOpenIDConnectProvidersInput) (*iam.ListOpenIDConnectProvidersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListOpenIDConnectProviders", arg0) + ret0, _ := ret[0].(*iam.ListOpenIDConnectProvidersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListOpenIDConnectProviders indicates an expected call of ListOpenIDConnectProviders +func (mr *MockIAMAPIMockRecorder) ListOpenIDConnectProviders(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpenIDConnectProviders", reflect.TypeOf((*MockIAMAPI)(nil).ListOpenIDConnectProviders), arg0) +} + +// ListOpenIDConnectProvidersRequest mocks base method +func (m *MockIAMAPI) ListOpenIDConnectProvidersRequest(arg0 *iam.ListOpenIDConnectProvidersInput) (*request.Request, *iam.ListOpenIDConnectProvidersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListOpenIDConnectProvidersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListOpenIDConnectProvidersOutput) + return ret0, ret1 +} + +// ListOpenIDConnectProvidersRequest indicates an expected call of ListOpenIDConnectProvidersRequest +func (mr *MockIAMAPIMockRecorder) ListOpenIDConnectProvidersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpenIDConnectProvidersRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListOpenIDConnectProvidersRequest), arg0) +} + +// ListOpenIDConnectProvidersWithContext mocks base method +func (m *MockIAMAPI) ListOpenIDConnectProvidersWithContext(arg0 context.Context, arg1 *iam.ListOpenIDConnectProvidersInput, arg2 ...request.Option) (*iam.ListOpenIDConnectProvidersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListOpenIDConnectProvidersWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListOpenIDConnectProvidersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListOpenIDConnectProvidersWithContext indicates an expected call of ListOpenIDConnectProvidersWithContext +func (mr *MockIAMAPIMockRecorder) ListOpenIDConnectProvidersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOpenIDConnectProvidersWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListOpenIDConnectProvidersWithContext), varargs...) +} + +// ListPolicies mocks base method +func (m *MockIAMAPI) ListPolicies(arg0 *iam.ListPoliciesInput) (*iam.ListPoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPolicies", arg0) + ret0, _ := ret[0].(*iam.ListPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPolicies indicates an expected call of ListPolicies +func (mr *MockIAMAPIMockRecorder) ListPolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPolicies", reflect.TypeOf((*MockIAMAPI)(nil).ListPolicies), arg0) +} + +// ListPoliciesGrantingServiceAccess mocks base method +func (m *MockIAMAPI) ListPoliciesGrantingServiceAccess(arg0 *iam.ListPoliciesGrantingServiceAccessInput) (*iam.ListPoliciesGrantingServiceAccessOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPoliciesGrantingServiceAccess", arg0) + ret0, _ := ret[0].(*iam.ListPoliciesGrantingServiceAccessOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPoliciesGrantingServiceAccess indicates an expected call of ListPoliciesGrantingServiceAccess +func (mr *MockIAMAPIMockRecorder) ListPoliciesGrantingServiceAccess(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoliciesGrantingServiceAccess", reflect.TypeOf((*MockIAMAPI)(nil).ListPoliciesGrantingServiceAccess), arg0) +} + +// ListPoliciesGrantingServiceAccessRequest mocks base method +func (m *MockIAMAPI) ListPoliciesGrantingServiceAccessRequest(arg0 *iam.ListPoliciesGrantingServiceAccessInput) (*request.Request, *iam.ListPoliciesGrantingServiceAccessOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPoliciesGrantingServiceAccessRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListPoliciesGrantingServiceAccessOutput) + return ret0, ret1 +} + +// ListPoliciesGrantingServiceAccessRequest indicates an expected call of ListPoliciesGrantingServiceAccessRequest +func (mr *MockIAMAPIMockRecorder) ListPoliciesGrantingServiceAccessRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoliciesGrantingServiceAccessRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListPoliciesGrantingServiceAccessRequest), arg0) +} + +// ListPoliciesGrantingServiceAccessWithContext mocks base method +func (m *MockIAMAPI) ListPoliciesGrantingServiceAccessWithContext(arg0 context.Context, arg1 *iam.ListPoliciesGrantingServiceAccessInput, arg2 ...request.Option) (*iam.ListPoliciesGrantingServiceAccessOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPoliciesGrantingServiceAccessWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListPoliciesGrantingServiceAccessOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPoliciesGrantingServiceAccessWithContext indicates an expected call of ListPoliciesGrantingServiceAccessWithContext +func (mr *MockIAMAPIMockRecorder) ListPoliciesGrantingServiceAccessWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoliciesGrantingServiceAccessWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListPoliciesGrantingServiceAccessWithContext), varargs...) +} + +// ListPoliciesPages mocks base method +func (m *MockIAMAPI) ListPoliciesPages(arg0 *iam.ListPoliciesInput, arg1 func(*iam.ListPoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPoliciesPages indicates an expected call of ListPoliciesPages +func (mr *MockIAMAPIMockRecorder) ListPoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoliciesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListPoliciesPages), arg0, arg1) +} + +// ListPoliciesPagesWithContext mocks base method +func (m *MockIAMAPI) ListPoliciesPagesWithContext(arg0 context.Context, arg1 *iam.ListPoliciesInput, arg2 func(*iam.ListPoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPoliciesPagesWithContext indicates an expected call of ListPoliciesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListPoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoliciesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListPoliciesPagesWithContext), varargs...) +} + +// ListPoliciesRequest mocks base method +func (m *MockIAMAPI) ListPoliciesRequest(arg0 *iam.ListPoliciesInput) (*request.Request, *iam.ListPoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListPoliciesOutput) + return ret0, ret1 +} + +// ListPoliciesRequest indicates an expected call of ListPoliciesRequest +func (mr *MockIAMAPIMockRecorder) ListPoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoliciesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListPoliciesRequest), arg0) +} + +// ListPoliciesWithContext mocks base method +func (m *MockIAMAPI) ListPoliciesWithContext(arg0 context.Context, arg1 *iam.ListPoliciesInput, arg2 ...request.Option) (*iam.ListPoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPoliciesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPoliciesWithContext indicates an expected call of ListPoliciesWithContext +func (mr *MockIAMAPIMockRecorder) ListPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPoliciesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListPoliciesWithContext), varargs...) +} + +// ListPolicyVersions mocks base method +func (m *MockIAMAPI) ListPolicyVersions(arg0 *iam.ListPolicyVersionsInput) (*iam.ListPolicyVersionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPolicyVersions", arg0) + ret0, _ := ret[0].(*iam.ListPolicyVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPolicyVersions indicates an expected call of ListPolicyVersions +func (mr *MockIAMAPIMockRecorder) ListPolicyVersions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPolicyVersions", reflect.TypeOf((*MockIAMAPI)(nil).ListPolicyVersions), arg0) +} + +// ListPolicyVersionsPages mocks base method +func (m *MockIAMAPI) ListPolicyVersionsPages(arg0 *iam.ListPolicyVersionsInput, arg1 func(*iam.ListPolicyVersionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPolicyVersionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPolicyVersionsPages indicates an expected call of ListPolicyVersionsPages +func (mr *MockIAMAPIMockRecorder) ListPolicyVersionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPolicyVersionsPages", reflect.TypeOf((*MockIAMAPI)(nil).ListPolicyVersionsPages), arg0, arg1) +} + +// ListPolicyVersionsPagesWithContext mocks base method +func (m *MockIAMAPI) ListPolicyVersionsPagesWithContext(arg0 context.Context, arg1 *iam.ListPolicyVersionsInput, arg2 func(*iam.ListPolicyVersionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPolicyVersionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPolicyVersionsPagesWithContext indicates an expected call of ListPolicyVersionsPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListPolicyVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPolicyVersionsPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListPolicyVersionsPagesWithContext), varargs...) +} + +// ListPolicyVersionsRequest mocks base method +func (m *MockIAMAPI) ListPolicyVersionsRequest(arg0 *iam.ListPolicyVersionsInput) (*request.Request, *iam.ListPolicyVersionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPolicyVersionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListPolicyVersionsOutput) + return ret0, ret1 +} + +// ListPolicyVersionsRequest indicates an expected call of ListPolicyVersionsRequest +func (mr *MockIAMAPIMockRecorder) ListPolicyVersionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPolicyVersionsRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListPolicyVersionsRequest), arg0) +} + +// ListPolicyVersionsWithContext mocks base method +func (m *MockIAMAPI) ListPolicyVersionsWithContext(arg0 context.Context, arg1 *iam.ListPolicyVersionsInput, arg2 ...request.Option) (*iam.ListPolicyVersionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPolicyVersionsWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListPolicyVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPolicyVersionsWithContext indicates an expected call of ListPolicyVersionsWithContext +func (mr *MockIAMAPIMockRecorder) ListPolicyVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPolicyVersionsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListPolicyVersionsWithContext), varargs...) +} + +// ListRolePolicies mocks base method +func (m *MockIAMAPI) ListRolePolicies(arg0 *iam.ListRolePoliciesInput) (*iam.ListRolePoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRolePolicies", arg0) + ret0, _ := ret[0].(*iam.ListRolePoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRolePolicies indicates an expected call of ListRolePolicies +func (mr *MockIAMAPIMockRecorder) ListRolePolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolePolicies", reflect.TypeOf((*MockIAMAPI)(nil).ListRolePolicies), arg0) +} + +// ListRolePoliciesPages mocks base method +func (m *MockIAMAPI) ListRolePoliciesPages(arg0 *iam.ListRolePoliciesInput, arg1 func(*iam.ListRolePoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRolePoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRolePoliciesPages indicates an expected call of ListRolePoliciesPages +func (mr *MockIAMAPIMockRecorder) ListRolePoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolePoliciesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListRolePoliciesPages), arg0, arg1) +} + +// ListRolePoliciesPagesWithContext mocks base method +func (m *MockIAMAPI) ListRolePoliciesPagesWithContext(arg0 context.Context, arg1 *iam.ListRolePoliciesInput, arg2 func(*iam.ListRolePoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRolePoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRolePoliciesPagesWithContext indicates an expected call of ListRolePoliciesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListRolePoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolePoliciesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListRolePoliciesPagesWithContext), varargs...) +} + +// ListRolePoliciesRequest mocks base method +func (m *MockIAMAPI) ListRolePoliciesRequest(arg0 *iam.ListRolePoliciesInput) (*request.Request, *iam.ListRolePoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRolePoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListRolePoliciesOutput) + return ret0, ret1 +} + +// ListRolePoliciesRequest indicates an expected call of ListRolePoliciesRequest +func (mr *MockIAMAPIMockRecorder) ListRolePoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolePoliciesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListRolePoliciesRequest), arg0) +} + +// ListRolePoliciesWithContext mocks base method +func (m *MockIAMAPI) ListRolePoliciesWithContext(arg0 context.Context, arg1 *iam.ListRolePoliciesInput, arg2 ...request.Option) (*iam.ListRolePoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRolePoliciesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListRolePoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRolePoliciesWithContext indicates an expected call of ListRolePoliciesWithContext +func (mr *MockIAMAPIMockRecorder) ListRolePoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolePoliciesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListRolePoliciesWithContext), varargs...) +} + +// ListRoleTags mocks base method +func (m *MockIAMAPI) ListRoleTags(arg0 *iam.ListRoleTagsInput) (*iam.ListRoleTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRoleTags", arg0) + ret0, _ := ret[0].(*iam.ListRoleTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRoleTags indicates an expected call of ListRoleTags +func (mr *MockIAMAPIMockRecorder) ListRoleTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRoleTags", reflect.TypeOf((*MockIAMAPI)(nil).ListRoleTags), arg0) +} + +// ListRoleTagsRequest mocks base method +func (m *MockIAMAPI) ListRoleTagsRequest(arg0 *iam.ListRoleTagsInput) (*request.Request, *iam.ListRoleTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRoleTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListRoleTagsOutput) + return ret0, ret1 +} + +// ListRoleTagsRequest indicates an expected call of ListRoleTagsRequest +func (mr *MockIAMAPIMockRecorder) ListRoleTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRoleTagsRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListRoleTagsRequest), arg0) +} + +// ListRoleTagsWithContext mocks base method +func (m *MockIAMAPI) ListRoleTagsWithContext(arg0 context.Context, arg1 *iam.ListRoleTagsInput, arg2 ...request.Option) (*iam.ListRoleTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRoleTagsWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListRoleTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRoleTagsWithContext indicates an expected call of ListRoleTagsWithContext +func (mr *MockIAMAPIMockRecorder) ListRoleTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRoleTagsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListRoleTagsWithContext), varargs...) +} + +// ListRoles mocks base method +func (m *MockIAMAPI) ListRoles(arg0 *iam.ListRolesInput) (*iam.ListRolesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRoles", arg0) + ret0, _ := ret[0].(*iam.ListRolesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRoles indicates an expected call of ListRoles +func (mr *MockIAMAPIMockRecorder) ListRoles(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRoles", reflect.TypeOf((*MockIAMAPI)(nil).ListRoles), arg0) +} + +// ListRolesPages mocks base method +func (m *MockIAMAPI) ListRolesPages(arg0 *iam.ListRolesInput, arg1 func(*iam.ListRolesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRolesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRolesPages indicates an expected call of ListRolesPages +func (mr *MockIAMAPIMockRecorder) ListRolesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListRolesPages), arg0, arg1) +} + +// ListRolesPagesWithContext mocks base method +func (m *MockIAMAPI) ListRolesPagesWithContext(arg0 context.Context, arg1 *iam.ListRolesInput, arg2 func(*iam.ListRolesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRolesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRolesPagesWithContext indicates an expected call of ListRolesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListRolesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListRolesPagesWithContext), varargs...) +} + +// ListRolesRequest mocks base method +func (m *MockIAMAPI) ListRolesRequest(arg0 *iam.ListRolesInput) (*request.Request, *iam.ListRolesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRolesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListRolesOutput) + return ret0, ret1 +} + +// ListRolesRequest indicates an expected call of ListRolesRequest +func (mr *MockIAMAPIMockRecorder) ListRolesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListRolesRequest), arg0) +} + +// ListRolesWithContext mocks base method +func (m *MockIAMAPI) ListRolesWithContext(arg0 context.Context, arg1 *iam.ListRolesInput, arg2 ...request.Option) (*iam.ListRolesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRolesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListRolesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRolesWithContext indicates an expected call of ListRolesWithContext +func (mr *MockIAMAPIMockRecorder) ListRolesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRolesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListRolesWithContext), varargs...) +} + +// ListSAMLProviders mocks base method +func (m *MockIAMAPI) ListSAMLProviders(arg0 *iam.ListSAMLProvidersInput) (*iam.ListSAMLProvidersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListSAMLProviders", arg0) + ret0, _ := ret[0].(*iam.ListSAMLProvidersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListSAMLProviders indicates an expected call of ListSAMLProviders +func (mr *MockIAMAPIMockRecorder) ListSAMLProviders(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSAMLProviders", reflect.TypeOf((*MockIAMAPI)(nil).ListSAMLProviders), arg0) +} + +// ListSAMLProvidersRequest mocks base method +func (m *MockIAMAPI) ListSAMLProvidersRequest(arg0 *iam.ListSAMLProvidersInput) (*request.Request, *iam.ListSAMLProvidersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListSAMLProvidersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListSAMLProvidersOutput) + return ret0, ret1 +} + +// ListSAMLProvidersRequest indicates an expected call of ListSAMLProvidersRequest +func (mr *MockIAMAPIMockRecorder) ListSAMLProvidersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSAMLProvidersRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListSAMLProvidersRequest), arg0) +} + +// ListSAMLProvidersWithContext mocks base method +func (m *MockIAMAPI) ListSAMLProvidersWithContext(arg0 context.Context, arg1 *iam.ListSAMLProvidersInput, arg2 ...request.Option) (*iam.ListSAMLProvidersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListSAMLProvidersWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListSAMLProvidersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListSAMLProvidersWithContext indicates an expected call of ListSAMLProvidersWithContext +func (mr *MockIAMAPIMockRecorder) ListSAMLProvidersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSAMLProvidersWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListSAMLProvidersWithContext), varargs...) +} + +// ListSSHPublicKeys mocks base method +func (m *MockIAMAPI) ListSSHPublicKeys(arg0 *iam.ListSSHPublicKeysInput) (*iam.ListSSHPublicKeysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListSSHPublicKeys", arg0) + ret0, _ := ret[0].(*iam.ListSSHPublicKeysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListSSHPublicKeys indicates an expected call of ListSSHPublicKeys +func (mr *MockIAMAPIMockRecorder) ListSSHPublicKeys(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSSHPublicKeys", reflect.TypeOf((*MockIAMAPI)(nil).ListSSHPublicKeys), arg0) +} + +// ListSSHPublicKeysPages mocks base method +func (m *MockIAMAPI) ListSSHPublicKeysPages(arg0 *iam.ListSSHPublicKeysInput, arg1 func(*iam.ListSSHPublicKeysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListSSHPublicKeysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListSSHPublicKeysPages indicates an expected call of ListSSHPublicKeysPages +func (mr *MockIAMAPIMockRecorder) ListSSHPublicKeysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSSHPublicKeysPages", reflect.TypeOf((*MockIAMAPI)(nil).ListSSHPublicKeysPages), arg0, arg1) +} + +// ListSSHPublicKeysPagesWithContext mocks base method +func (m *MockIAMAPI) ListSSHPublicKeysPagesWithContext(arg0 context.Context, arg1 *iam.ListSSHPublicKeysInput, arg2 func(*iam.ListSSHPublicKeysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListSSHPublicKeysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListSSHPublicKeysPagesWithContext indicates an expected call of ListSSHPublicKeysPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListSSHPublicKeysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSSHPublicKeysPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListSSHPublicKeysPagesWithContext), varargs...) +} + +// ListSSHPublicKeysRequest mocks base method +func (m *MockIAMAPI) ListSSHPublicKeysRequest(arg0 *iam.ListSSHPublicKeysInput) (*request.Request, *iam.ListSSHPublicKeysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListSSHPublicKeysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListSSHPublicKeysOutput) + return ret0, ret1 +} + +// ListSSHPublicKeysRequest indicates an expected call of ListSSHPublicKeysRequest +func (mr *MockIAMAPIMockRecorder) ListSSHPublicKeysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSSHPublicKeysRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListSSHPublicKeysRequest), arg0) +} + +// ListSSHPublicKeysWithContext mocks base method +func (m *MockIAMAPI) ListSSHPublicKeysWithContext(arg0 context.Context, arg1 *iam.ListSSHPublicKeysInput, arg2 ...request.Option) (*iam.ListSSHPublicKeysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListSSHPublicKeysWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListSSHPublicKeysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListSSHPublicKeysWithContext indicates an expected call of ListSSHPublicKeysWithContext +func (mr *MockIAMAPIMockRecorder) ListSSHPublicKeysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSSHPublicKeysWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListSSHPublicKeysWithContext), varargs...) +} + +// ListServerCertificates mocks base method +func (m *MockIAMAPI) ListServerCertificates(arg0 *iam.ListServerCertificatesInput) (*iam.ListServerCertificatesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListServerCertificates", arg0) + ret0, _ := ret[0].(*iam.ListServerCertificatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListServerCertificates indicates an expected call of ListServerCertificates +func (mr *MockIAMAPIMockRecorder) ListServerCertificates(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerCertificates", reflect.TypeOf((*MockIAMAPI)(nil).ListServerCertificates), arg0) +} + +// ListServerCertificatesPages mocks base method +func (m *MockIAMAPI) ListServerCertificatesPages(arg0 *iam.ListServerCertificatesInput, arg1 func(*iam.ListServerCertificatesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListServerCertificatesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListServerCertificatesPages indicates an expected call of ListServerCertificatesPages +func (mr *MockIAMAPIMockRecorder) ListServerCertificatesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerCertificatesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListServerCertificatesPages), arg0, arg1) +} + +// ListServerCertificatesPagesWithContext mocks base method +func (m *MockIAMAPI) ListServerCertificatesPagesWithContext(arg0 context.Context, arg1 *iam.ListServerCertificatesInput, arg2 func(*iam.ListServerCertificatesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListServerCertificatesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListServerCertificatesPagesWithContext indicates an expected call of ListServerCertificatesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListServerCertificatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerCertificatesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListServerCertificatesPagesWithContext), varargs...) +} + +// ListServerCertificatesRequest mocks base method +func (m *MockIAMAPI) ListServerCertificatesRequest(arg0 *iam.ListServerCertificatesInput) (*request.Request, *iam.ListServerCertificatesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListServerCertificatesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListServerCertificatesOutput) + return ret0, ret1 +} + +// ListServerCertificatesRequest indicates an expected call of ListServerCertificatesRequest +func (mr *MockIAMAPIMockRecorder) ListServerCertificatesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerCertificatesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListServerCertificatesRequest), arg0) +} + +// ListServerCertificatesWithContext mocks base method +func (m *MockIAMAPI) ListServerCertificatesWithContext(arg0 context.Context, arg1 *iam.ListServerCertificatesInput, arg2 ...request.Option) (*iam.ListServerCertificatesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListServerCertificatesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListServerCertificatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListServerCertificatesWithContext indicates an expected call of ListServerCertificatesWithContext +func (mr *MockIAMAPIMockRecorder) ListServerCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServerCertificatesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListServerCertificatesWithContext), varargs...) +} + +// ListServiceSpecificCredentials mocks base method +func (m *MockIAMAPI) ListServiceSpecificCredentials(arg0 *iam.ListServiceSpecificCredentialsInput) (*iam.ListServiceSpecificCredentialsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListServiceSpecificCredentials", arg0) + ret0, _ := ret[0].(*iam.ListServiceSpecificCredentialsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListServiceSpecificCredentials indicates an expected call of ListServiceSpecificCredentials +func (mr *MockIAMAPIMockRecorder) ListServiceSpecificCredentials(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServiceSpecificCredentials", reflect.TypeOf((*MockIAMAPI)(nil).ListServiceSpecificCredentials), arg0) +} + +// ListServiceSpecificCredentialsRequest mocks base method +func (m *MockIAMAPI) ListServiceSpecificCredentialsRequest(arg0 *iam.ListServiceSpecificCredentialsInput) (*request.Request, *iam.ListServiceSpecificCredentialsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListServiceSpecificCredentialsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListServiceSpecificCredentialsOutput) + return ret0, ret1 +} + +// ListServiceSpecificCredentialsRequest indicates an expected call of ListServiceSpecificCredentialsRequest +func (mr *MockIAMAPIMockRecorder) ListServiceSpecificCredentialsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServiceSpecificCredentialsRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListServiceSpecificCredentialsRequest), arg0) +} + +// ListServiceSpecificCredentialsWithContext mocks base method +func (m *MockIAMAPI) ListServiceSpecificCredentialsWithContext(arg0 context.Context, arg1 *iam.ListServiceSpecificCredentialsInput, arg2 ...request.Option) (*iam.ListServiceSpecificCredentialsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListServiceSpecificCredentialsWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListServiceSpecificCredentialsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListServiceSpecificCredentialsWithContext indicates an expected call of ListServiceSpecificCredentialsWithContext +func (mr *MockIAMAPIMockRecorder) ListServiceSpecificCredentialsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServiceSpecificCredentialsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListServiceSpecificCredentialsWithContext), varargs...) +} + +// ListSigningCertificates mocks base method +func (m *MockIAMAPI) ListSigningCertificates(arg0 *iam.ListSigningCertificatesInput) (*iam.ListSigningCertificatesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListSigningCertificates", arg0) + ret0, _ := ret[0].(*iam.ListSigningCertificatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListSigningCertificates indicates an expected call of ListSigningCertificates +func (mr *MockIAMAPIMockRecorder) ListSigningCertificates(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSigningCertificates", reflect.TypeOf((*MockIAMAPI)(nil).ListSigningCertificates), arg0) +} + +// ListSigningCertificatesPages mocks base method +func (m *MockIAMAPI) ListSigningCertificatesPages(arg0 *iam.ListSigningCertificatesInput, arg1 func(*iam.ListSigningCertificatesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListSigningCertificatesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListSigningCertificatesPages indicates an expected call of ListSigningCertificatesPages +func (mr *MockIAMAPIMockRecorder) ListSigningCertificatesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSigningCertificatesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListSigningCertificatesPages), arg0, arg1) +} + +// ListSigningCertificatesPagesWithContext mocks base method +func (m *MockIAMAPI) ListSigningCertificatesPagesWithContext(arg0 context.Context, arg1 *iam.ListSigningCertificatesInput, arg2 func(*iam.ListSigningCertificatesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListSigningCertificatesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListSigningCertificatesPagesWithContext indicates an expected call of ListSigningCertificatesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListSigningCertificatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSigningCertificatesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListSigningCertificatesPagesWithContext), varargs...) +} + +// ListSigningCertificatesRequest mocks base method +func (m *MockIAMAPI) ListSigningCertificatesRequest(arg0 *iam.ListSigningCertificatesInput) (*request.Request, *iam.ListSigningCertificatesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListSigningCertificatesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListSigningCertificatesOutput) + return ret0, ret1 +} + +// ListSigningCertificatesRequest indicates an expected call of ListSigningCertificatesRequest +func (mr *MockIAMAPIMockRecorder) ListSigningCertificatesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSigningCertificatesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListSigningCertificatesRequest), arg0) +} + +// ListSigningCertificatesWithContext mocks base method +func (m *MockIAMAPI) ListSigningCertificatesWithContext(arg0 context.Context, arg1 *iam.ListSigningCertificatesInput, arg2 ...request.Option) (*iam.ListSigningCertificatesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListSigningCertificatesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListSigningCertificatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListSigningCertificatesWithContext indicates an expected call of ListSigningCertificatesWithContext +func (mr *MockIAMAPIMockRecorder) ListSigningCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSigningCertificatesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListSigningCertificatesWithContext), varargs...) +} + +// ListUserPolicies mocks base method +func (m *MockIAMAPI) ListUserPolicies(arg0 *iam.ListUserPoliciesInput) (*iam.ListUserPoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListUserPolicies", arg0) + ret0, _ := ret[0].(*iam.ListUserPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListUserPolicies indicates an expected call of ListUserPolicies +func (mr *MockIAMAPIMockRecorder) ListUserPolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPolicies", reflect.TypeOf((*MockIAMAPI)(nil).ListUserPolicies), arg0) +} + +// ListUserPoliciesPages mocks base method +func (m *MockIAMAPI) ListUserPoliciesPages(arg0 *iam.ListUserPoliciesInput, arg1 func(*iam.ListUserPoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListUserPoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListUserPoliciesPages indicates an expected call of ListUserPoliciesPages +func (mr *MockIAMAPIMockRecorder) ListUserPoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoliciesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListUserPoliciesPages), arg0, arg1) +} + +// ListUserPoliciesPagesWithContext mocks base method +func (m *MockIAMAPI) ListUserPoliciesPagesWithContext(arg0 context.Context, arg1 *iam.ListUserPoliciesInput, arg2 func(*iam.ListUserPoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListUserPoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListUserPoliciesPagesWithContext indicates an expected call of ListUserPoliciesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListUserPoliciesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoliciesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListUserPoliciesPagesWithContext), varargs...) +} + +// ListUserPoliciesRequest mocks base method +func (m *MockIAMAPI) ListUserPoliciesRequest(arg0 *iam.ListUserPoliciesInput) (*request.Request, *iam.ListUserPoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListUserPoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListUserPoliciesOutput) + return ret0, ret1 +} + +// ListUserPoliciesRequest indicates an expected call of ListUserPoliciesRequest +func (mr *MockIAMAPIMockRecorder) ListUserPoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoliciesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListUserPoliciesRequest), arg0) +} + +// ListUserPoliciesWithContext mocks base method +func (m *MockIAMAPI) ListUserPoliciesWithContext(arg0 context.Context, arg1 *iam.ListUserPoliciesInput, arg2 ...request.Option) (*iam.ListUserPoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListUserPoliciesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListUserPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListUserPoliciesWithContext indicates an expected call of ListUserPoliciesWithContext +func (mr *MockIAMAPIMockRecorder) ListUserPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoliciesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListUserPoliciesWithContext), varargs...) +} + +// ListUserTags mocks base method +func (m *MockIAMAPI) ListUserTags(arg0 *iam.ListUserTagsInput) (*iam.ListUserTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListUserTags", arg0) + ret0, _ := ret[0].(*iam.ListUserTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListUserTags indicates an expected call of ListUserTags +func (mr *MockIAMAPIMockRecorder) ListUserTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserTags", reflect.TypeOf((*MockIAMAPI)(nil).ListUserTags), arg0) +} + +// ListUserTagsRequest mocks base method +func (m *MockIAMAPI) ListUserTagsRequest(arg0 *iam.ListUserTagsInput) (*request.Request, *iam.ListUserTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListUserTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListUserTagsOutput) + return ret0, ret1 +} + +// ListUserTagsRequest indicates an expected call of ListUserTagsRequest +func (mr *MockIAMAPIMockRecorder) ListUserTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserTagsRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListUserTagsRequest), arg0) +} + +// ListUserTagsWithContext mocks base method +func (m *MockIAMAPI) ListUserTagsWithContext(arg0 context.Context, arg1 *iam.ListUserTagsInput, arg2 ...request.Option) (*iam.ListUserTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListUserTagsWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListUserTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListUserTagsWithContext indicates an expected call of ListUserTagsWithContext +func (mr *MockIAMAPIMockRecorder) ListUserTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserTagsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListUserTagsWithContext), varargs...) +} + +// ListUsers mocks base method +func (m *MockIAMAPI) ListUsers(arg0 *iam.ListUsersInput) (*iam.ListUsersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListUsers", arg0) + ret0, _ := ret[0].(*iam.ListUsersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListUsers indicates an expected call of ListUsers +func (mr *MockIAMAPIMockRecorder) ListUsers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsers", reflect.TypeOf((*MockIAMAPI)(nil).ListUsers), arg0) +} + +// ListUsersPages mocks base method +func (m *MockIAMAPI) ListUsersPages(arg0 *iam.ListUsersInput, arg1 func(*iam.ListUsersOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListUsersPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListUsersPages indicates an expected call of ListUsersPages +func (mr *MockIAMAPIMockRecorder) ListUsersPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersPages", reflect.TypeOf((*MockIAMAPI)(nil).ListUsersPages), arg0, arg1) +} + +// ListUsersPagesWithContext mocks base method +func (m *MockIAMAPI) ListUsersPagesWithContext(arg0 context.Context, arg1 *iam.ListUsersInput, arg2 func(*iam.ListUsersOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListUsersPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListUsersPagesWithContext indicates an expected call of ListUsersPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListUsersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListUsersPagesWithContext), varargs...) +} + +// ListUsersRequest mocks base method +func (m *MockIAMAPI) ListUsersRequest(arg0 *iam.ListUsersInput) (*request.Request, *iam.ListUsersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListUsersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListUsersOutput) + return ret0, ret1 +} + +// ListUsersRequest indicates an expected call of ListUsersRequest +func (mr *MockIAMAPIMockRecorder) ListUsersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListUsersRequest), arg0) +} + +// ListUsersWithContext mocks base method +func (m *MockIAMAPI) ListUsersWithContext(arg0 context.Context, arg1 *iam.ListUsersInput, arg2 ...request.Option) (*iam.ListUsersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListUsersWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListUsersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListUsersWithContext indicates an expected call of ListUsersWithContext +func (mr *MockIAMAPIMockRecorder) ListUsersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListUsersWithContext), varargs...) +} + +// ListVirtualMFADevices mocks base method +func (m *MockIAMAPI) ListVirtualMFADevices(arg0 *iam.ListVirtualMFADevicesInput) (*iam.ListVirtualMFADevicesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListVirtualMFADevices", arg0) + ret0, _ := ret[0].(*iam.ListVirtualMFADevicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListVirtualMFADevices indicates an expected call of ListVirtualMFADevices +func (mr *MockIAMAPIMockRecorder) ListVirtualMFADevices(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVirtualMFADevices", reflect.TypeOf((*MockIAMAPI)(nil).ListVirtualMFADevices), arg0) +} + +// ListVirtualMFADevicesPages mocks base method +func (m *MockIAMAPI) ListVirtualMFADevicesPages(arg0 *iam.ListVirtualMFADevicesInput, arg1 func(*iam.ListVirtualMFADevicesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListVirtualMFADevicesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListVirtualMFADevicesPages indicates an expected call of ListVirtualMFADevicesPages +func (mr *MockIAMAPIMockRecorder) ListVirtualMFADevicesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVirtualMFADevicesPages", reflect.TypeOf((*MockIAMAPI)(nil).ListVirtualMFADevicesPages), arg0, arg1) +} + +// ListVirtualMFADevicesPagesWithContext mocks base method +func (m *MockIAMAPI) ListVirtualMFADevicesPagesWithContext(arg0 context.Context, arg1 *iam.ListVirtualMFADevicesInput, arg2 func(*iam.ListVirtualMFADevicesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListVirtualMFADevicesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListVirtualMFADevicesPagesWithContext indicates an expected call of ListVirtualMFADevicesPagesWithContext +func (mr *MockIAMAPIMockRecorder) ListVirtualMFADevicesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVirtualMFADevicesPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListVirtualMFADevicesPagesWithContext), varargs...) +} + +// ListVirtualMFADevicesRequest mocks base method +func (m *MockIAMAPI) ListVirtualMFADevicesRequest(arg0 *iam.ListVirtualMFADevicesInput) (*request.Request, *iam.ListVirtualMFADevicesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListVirtualMFADevicesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ListVirtualMFADevicesOutput) + return ret0, ret1 +} + +// ListVirtualMFADevicesRequest indicates an expected call of ListVirtualMFADevicesRequest +func (mr *MockIAMAPIMockRecorder) ListVirtualMFADevicesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVirtualMFADevicesRequest", reflect.TypeOf((*MockIAMAPI)(nil).ListVirtualMFADevicesRequest), arg0) +} + +// ListVirtualMFADevicesWithContext mocks base method +func (m *MockIAMAPI) ListVirtualMFADevicesWithContext(arg0 context.Context, arg1 *iam.ListVirtualMFADevicesInput, arg2 ...request.Option) (*iam.ListVirtualMFADevicesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListVirtualMFADevicesWithContext", varargs...) + ret0, _ := ret[0].(*iam.ListVirtualMFADevicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListVirtualMFADevicesWithContext indicates an expected call of ListVirtualMFADevicesWithContext +func (mr *MockIAMAPIMockRecorder) ListVirtualMFADevicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVirtualMFADevicesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ListVirtualMFADevicesWithContext), varargs...) +} + +// PutGroupPolicy mocks base method +func (m *MockIAMAPI) PutGroupPolicy(arg0 *iam.PutGroupPolicyInput) (*iam.PutGroupPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutGroupPolicy", arg0) + ret0, _ := ret[0].(*iam.PutGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutGroupPolicy indicates an expected call of PutGroupPolicy +func (mr *MockIAMAPIMockRecorder) PutGroupPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutGroupPolicy", reflect.TypeOf((*MockIAMAPI)(nil).PutGroupPolicy), arg0) +} + +// PutGroupPolicyRequest mocks base method +func (m *MockIAMAPI) PutGroupPolicyRequest(arg0 *iam.PutGroupPolicyInput) (*request.Request, *iam.PutGroupPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutGroupPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.PutGroupPolicyOutput) + return ret0, ret1 +} + +// PutGroupPolicyRequest indicates an expected call of PutGroupPolicyRequest +func (mr *MockIAMAPIMockRecorder) PutGroupPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutGroupPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).PutGroupPolicyRequest), arg0) +} + +// PutGroupPolicyWithContext mocks base method +func (m *MockIAMAPI) PutGroupPolicyWithContext(arg0 context.Context, arg1 *iam.PutGroupPolicyInput, arg2 ...request.Option) (*iam.PutGroupPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutGroupPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.PutGroupPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutGroupPolicyWithContext indicates an expected call of PutGroupPolicyWithContext +func (mr *MockIAMAPIMockRecorder) PutGroupPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutGroupPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).PutGroupPolicyWithContext), varargs...) +} + +// PutRolePermissionsBoundary mocks base method +func (m *MockIAMAPI) PutRolePermissionsBoundary(arg0 *iam.PutRolePermissionsBoundaryInput) (*iam.PutRolePermissionsBoundaryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRolePermissionsBoundary", arg0) + ret0, _ := ret[0].(*iam.PutRolePermissionsBoundaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRolePermissionsBoundary indicates an expected call of PutRolePermissionsBoundary +func (mr *MockIAMAPIMockRecorder) PutRolePermissionsBoundary(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRolePermissionsBoundary", reflect.TypeOf((*MockIAMAPI)(nil).PutRolePermissionsBoundary), arg0) +} + +// PutRolePermissionsBoundaryRequest mocks base method +func (m *MockIAMAPI) PutRolePermissionsBoundaryRequest(arg0 *iam.PutRolePermissionsBoundaryInput) (*request.Request, *iam.PutRolePermissionsBoundaryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRolePermissionsBoundaryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.PutRolePermissionsBoundaryOutput) + return ret0, ret1 +} + +// PutRolePermissionsBoundaryRequest indicates an expected call of PutRolePermissionsBoundaryRequest +func (mr *MockIAMAPIMockRecorder) PutRolePermissionsBoundaryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRolePermissionsBoundaryRequest", reflect.TypeOf((*MockIAMAPI)(nil).PutRolePermissionsBoundaryRequest), arg0) +} + +// PutRolePermissionsBoundaryWithContext mocks base method +func (m *MockIAMAPI) PutRolePermissionsBoundaryWithContext(arg0 context.Context, arg1 *iam.PutRolePermissionsBoundaryInput, arg2 ...request.Option) (*iam.PutRolePermissionsBoundaryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutRolePermissionsBoundaryWithContext", varargs...) + ret0, _ := ret[0].(*iam.PutRolePermissionsBoundaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRolePermissionsBoundaryWithContext indicates an expected call of PutRolePermissionsBoundaryWithContext +func (mr *MockIAMAPIMockRecorder) PutRolePermissionsBoundaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRolePermissionsBoundaryWithContext", reflect.TypeOf((*MockIAMAPI)(nil).PutRolePermissionsBoundaryWithContext), varargs...) +} + +// PutRolePolicy mocks base method +func (m *MockIAMAPI) PutRolePolicy(arg0 *iam.PutRolePolicyInput) (*iam.PutRolePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRolePolicy", arg0) + ret0, _ := ret[0].(*iam.PutRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRolePolicy indicates an expected call of PutRolePolicy +func (mr *MockIAMAPIMockRecorder) PutRolePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRolePolicy", reflect.TypeOf((*MockIAMAPI)(nil).PutRolePolicy), arg0) +} + +// PutRolePolicyRequest mocks base method +func (m *MockIAMAPI) PutRolePolicyRequest(arg0 *iam.PutRolePolicyInput) (*request.Request, *iam.PutRolePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutRolePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.PutRolePolicyOutput) + return ret0, ret1 +} + +// PutRolePolicyRequest indicates an expected call of PutRolePolicyRequest +func (mr *MockIAMAPIMockRecorder) PutRolePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRolePolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).PutRolePolicyRequest), arg0) +} + +// PutRolePolicyWithContext mocks base method +func (m *MockIAMAPI) PutRolePolicyWithContext(arg0 context.Context, arg1 *iam.PutRolePolicyInput, arg2 ...request.Option) (*iam.PutRolePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutRolePolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.PutRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutRolePolicyWithContext indicates an expected call of PutRolePolicyWithContext +func (mr *MockIAMAPIMockRecorder) PutRolePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRolePolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).PutRolePolicyWithContext), varargs...) +} + +// PutUserPermissionsBoundary mocks base method +func (m *MockIAMAPI) PutUserPermissionsBoundary(arg0 *iam.PutUserPermissionsBoundaryInput) (*iam.PutUserPermissionsBoundaryOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutUserPermissionsBoundary", arg0) + ret0, _ := ret[0].(*iam.PutUserPermissionsBoundaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutUserPermissionsBoundary indicates an expected call of PutUserPermissionsBoundary +func (mr *MockIAMAPIMockRecorder) PutUserPermissionsBoundary(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutUserPermissionsBoundary", reflect.TypeOf((*MockIAMAPI)(nil).PutUserPermissionsBoundary), arg0) +} + +// PutUserPermissionsBoundaryRequest mocks base method +func (m *MockIAMAPI) PutUserPermissionsBoundaryRequest(arg0 *iam.PutUserPermissionsBoundaryInput) (*request.Request, *iam.PutUserPermissionsBoundaryOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutUserPermissionsBoundaryRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.PutUserPermissionsBoundaryOutput) + return ret0, ret1 +} + +// PutUserPermissionsBoundaryRequest indicates an expected call of PutUserPermissionsBoundaryRequest +func (mr *MockIAMAPIMockRecorder) PutUserPermissionsBoundaryRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutUserPermissionsBoundaryRequest", reflect.TypeOf((*MockIAMAPI)(nil).PutUserPermissionsBoundaryRequest), arg0) +} + +// PutUserPermissionsBoundaryWithContext mocks base method +func (m *MockIAMAPI) PutUserPermissionsBoundaryWithContext(arg0 context.Context, arg1 *iam.PutUserPermissionsBoundaryInput, arg2 ...request.Option) (*iam.PutUserPermissionsBoundaryOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutUserPermissionsBoundaryWithContext", varargs...) + ret0, _ := ret[0].(*iam.PutUserPermissionsBoundaryOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutUserPermissionsBoundaryWithContext indicates an expected call of PutUserPermissionsBoundaryWithContext +func (mr *MockIAMAPIMockRecorder) PutUserPermissionsBoundaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutUserPermissionsBoundaryWithContext", reflect.TypeOf((*MockIAMAPI)(nil).PutUserPermissionsBoundaryWithContext), varargs...) +} + +// PutUserPolicy mocks base method +func (m *MockIAMAPI) PutUserPolicy(arg0 *iam.PutUserPolicyInput) (*iam.PutUserPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutUserPolicy", arg0) + ret0, _ := ret[0].(*iam.PutUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutUserPolicy indicates an expected call of PutUserPolicy +func (mr *MockIAMAPIMockRecorder) PutUserPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutUserPolicy", reflect.TypeOf((*MockIAMAPI)(nil).PutUserPolicy), arg0) +} + +// PutUserPolicyRequest mocks base method +func (m *MockIAMAPI) PutUserPolicyRequest(arg0 *iam.PutUserPolicyInput) (*request.Request, *iam.PutUserPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutUserPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.PutUserPolicyOutput) + return ret0, ret1 +} + +// PutUserPolicyRequest indicates an expected call of PutUserPolicyRequest +func (mr *MockIAMAPIMockRecorder) PutUserPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutUserPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).PutUserPolicyRequest), arg0) +} + +// PutUserPolicyWithContext mocks base method +func (m *MockIAMAPI) PutUserPolicyWithContext(arg0 context.Context, arg1 *iam.PutUserPolicyInput, arg2 ...request.Option) (*iam.PutUserPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutUserPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.PutUserPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutUserPolicyWithContext indicates an expected call of PutUserPolicyWithContext +func (mr *MockIAMAPIMockRecorder) PutUserPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutUserPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).PutUserPolicyWithContext), varargs...) +} + +// RemoveClientIDFromOpenIDConnectProvider mocks base method +func (m *MockIAMAPI) RemoveClientIDFromOpenIDConnectProvider(arg0 *iam.RemoveClientIDFromOpenIDConnectProviderInput) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveClientIDFromOpenIDConnectProvider", arg0) + ret0, _ := ret[0].(*iam.RemoveClientIDFromOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveClientIDFromOpenIDConnectProvider indicates an expected call of RemoveClientIDFromOpenIDConnectProvider +func (mr *MockIAMAPIMockRecorder) RemoveClientIDFromOpenIDConnectProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClientIDFromOpenIDConnectProvider", reflect.TypeOf((*MockIAMAPI)(nil).RemoveClientIDFromOpenIDConnectProvider), arg0) +} + +// RemoveClientIDFromOpenIDConnectProviderRequest mocks base method +func (m *MockIAMAPI) RemoveClientIDFromOpenIDConnectProviderRequest(arg0 *iam.RemoveClientIDFromOpenIDConnectProviderInput) (*request.Request, *iam.RemoveClientIDFromOpenIDConnectProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveClientIDFromOpenIDConnectProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.RemoveClientIDFromOpenIDConnectProviderOutput) + return ret0, ret1 +} + +// RemoveClientIDFromOpenIDConnectProviderRequest indicates an expected call of RemoveClientIDFromOpenIDConnectProviderRequest +func (mr *MockIAMAPIMockRecorder) RemoveClientIDFromOpenIDConnectProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClientIDFromOpenIDConnectProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).RemoveClientIDFromOpenIDConnectProviderRequest), arg0) +} + +// RemoveClientIDFromOpenIDConnectProviderWithContext mocks base method +func (m *MockIAMAPI) RemoveClientIDFromOpenIDConnectProviderWithContext(arg0 context.Context, arg1 *iam.RemoveClientIDFromOpenIDConnectProviderInput, arg2 ...request.Option) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RemoveClientIDFromOpenIDConnectProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.RemoveClientIDFromOpenIDConnectProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveClientIDFromOpenIDConnectProviderWithContext indicates an expected call of RemoveClientIDFromOpenIDConnectProviderWithContext +func (mr *MockIAMAPIMockRecorder) RemoveClientIDFromOpenIDConnectProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClientIDFromOpenIDConnectProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).RemoveClientIDFromOpenIDConnectProviderWithContext), varargs...) +} + +// RemoveRoleFromInstanceProfile mocks base method +func (m *MockIAMAPI) RemoveRoleFromInstanceProfile(arg0 *iam.RemoveRoleFromInstanceProfileInput) (*iam.RemoveRoleFromInstanceProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveRoleFromInstanceProfile", arg0) + ret0, _ := ret[0].(*iam.RemoveRoleFromInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveRoleFromInstanceProfile indicates an expected call of RemoveRoleFromInstanceProfile +func (mr *MockIAMAPIMockRecorder) RemoveRoleFromInstanceProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromInstanceProfile", reflect.TypeOf((*MockIAMAPI)(nil).RemoveRoleFromInstanceProfile), arg0) +} + +// RemoveRoleFromInstanceProfileRequest mocks base method +func (m *MockIAMAPI) RemoveRoleFromInstanceProfileRequest(arg0 *iam.RemoveRoleFromInstanceProfileInput) (*request.Request, *iam.RemoveRoleFromInstanceProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveRoleFromInstanceProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.RemoveRoleFromInstanceProfileOutput) + return ret0, ret1 +} + +// RemoveRoleFromInstanceProfileRequest indicates an expected call of RemoveRoleFromInstanceProfileRequest +func (mr *MockIAMAPIMockRecorder) RemoveRoleFromInstanceProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromInstanceProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).RemoveRoleFromInstanceProfileRequest), arg0) +} + +// RemoveRoleFromInstanceProfileWithContext mocks base method +func (m *MockIAMAPI) RemoveRoleFromInstanceProfileWithContext(arg0 context.Context, arg1 *iam.RemoveRoleFromInstanceProfileInput, arg2 ...request.Option) (*iam.RemoveRoleFromInstanceProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RemoveRoleFromInstanceProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.RemoveRoleFromInstanceProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveRoleFromInstanceProfileWithContext indicates an expected call of RemoveRoleFromInstanceProfileWithContext +func (mr *MockIAMAPIMockRecorder) RemoveRoleFromInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRoleFromInstanceProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).RemoveRoleFromInstanceProfileWithContext), varargs...) +} + +// RemoveUserFromGroup mocks base method +func (m *MockIAMAPI) RemoveUserFromGroup(arg0 *iam.RemoveUserFromGroupInput) (*iam.RemoveUserFromGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveUserFromGroup", arg0) + ret0, _ := ret[0].(*iam.RemoveUserFromGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveUserFromGroup indicates an expected call of RemoveUserFromGroup +func (mr *MockIAMAPIMockRecorder) RemoveUserFromGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveUserFromGroup", reflect.TypeOf((*MockIAMAPI)(nil).RemoveUserFromGroup), arg0) +} + +// RemoveUserFromGroupRequest mocks base method +func (m *MockIAMAPI) RemoveUserFromGroupRequest(arg0 *iam.RemoveUserFromGroupInput) (*request.Request, *iam.RemoveUserFromGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveUserFromGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.RemoveUserFromGroupOutput) + return ret0, ret1 +} + +// RemoveUserFromGroupRequest indicates an expected call of RemoveUserFromGroupRequest +func (mr *MockIAMAPIMockRecorder) RemoveUserFromGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveUserFromGroupRequest", reflect.TypeOf((*MockIAMAPI)(nil).RemoveUserFromGroupRequest), arg0) +} + +// RemoveUserFromGroupWithContext mocks base method +func (m *MockIAMAPI) RemoveUserFromGroupWithContext(arg0 context.Context, arg1 *iam.RemoveUserFromGroupInput, arg2 ...request.Option) (*iam.RemoveUserFromGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RemoveUserFromGroupWithContext", varargs...) + ret0, _ := ret[0].(*iam.RemoveUserFromGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveUserFromGroupWithContext indicates an expected call of RemoveUserFromGroupWithContext +func (mr *MockIAMAPIMockRecorder) RemoveUserFromGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveUserFromGroupWithContext", reflect.TypeOf((*MockIAMAPI)(nil).RemoveUserFromGroupWithContext), varargs...) +} + +// ResetServiceSpecificCredential mocks base method +func (m *MockIAMAPI) ResetServiceSpecificCredential(arg0 *iam.ResetServiceSpecificCredentialInput) (*iam.ResetServiceSpecificCredentialOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetServiceSpecificCredential", arg0) + ret0, _ := ret[0].(*iam.ResetServiceSpecificCredentialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetServiceSpecificCredential indicates an expected call of ResetServiceSpecificCredential +func (mr *MockIAMAPIMockRecorder) ResetServiceSpecificCredential(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetServiceSpecificCredential", reflect.TypeOf((*MockIAMAPI)(nil).ResetServiceSpecificCredential), arg0) +} + +// ResetServiceSpecificCredentialRequest mocks base method +func (m *MockIAMAPI) ResetServiceSpecificCredentialRequest(arg0 *iam.ResetServiceSpecificCredentialInput) (*request.Request, *iam.ResetServiceSpecificCredentialOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResetServiceSpecificCredentialRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ResetServiceSpecificCredentialOutput) + return ret0, ret1 +} + +// ResetServiceSpecificCredentialRequest indicates an expected call of ResetServiceSpecificCredentialRequest +func (mr *MockIAMAPIMockRecorder) ResetServiceSpecificCredentialRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetServiceSpecificCredentialRequest", reflect.TypeOf((*MockIAMAPI)(nil).ResetServiceSpecificCredentialRequest), arg0) +} + +// ResetServiceSpecificCredentialWithContext mocks base method +func (m *MockIAMAPI) ResetServiceSpecificCredentialWithContext(arg0 context.Context, arg1 *iam.ResetServiceSpecificCredentialInput, arg2 ...request.Option) (*iam.ResetServiceSpecificCredentialOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResetServiceSpecificCredentialWithContext", varargs...) + ret0, _ := ret[0].(*iam.ResetServiceSpecificCredentialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResetServiceSpecificCredentialWithContext indicates an expected call of ResetServiceSpecificCredentialWithContext +func (mr *MockIAMAPIMockRecorder) ResetServiceSpecificCredentialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetServiceSpecificCredentialWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ResetServiceSpecificCredentialWithContext), varargs...) +} + +// ResyncMFADevice mocks base method +func (m *MockIAMAPI) ResyncMFADevice(arg0 *iam.ResyncMFADeviceInput) (*iam.ResyncMFADeviceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResyncMFADevice", arg0) + ret0, _ := ret[0].(*iam.ResyncMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResyncMFADevice indicates an expected call of ResyncMFADevice +func (mr *MockIAMAPIMockRecorder) ResyncMFADevice(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResyncMFADevice", reflect.TypeOf((*MockIAMAPI)(nil).ResyncMFADevice), arg0) +} + +// ResyncMFADeviceRequest mocks base method +func (m *MockIAMAPI) ResyncMFADeviceRequest(arg0 *iam.ResyncMFADeviceInput) (*request.Request, *iam.ResyncMFADeviceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResyncMFADeviceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.ResyncMFADeviceOutput) + return ret0, ret1 +} + +// ResyncMFADeviceRequest indicates an expected call of ResyncMFADeviceRequest +func (mr *MockIAMAPIMockRecorder) ResyncMFADeviceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResyncMFADeviceRequest", reflect.TypeOf((*MockIAMAPI)(nil).ResyncMFADeviceRequest), arg0) +} + +// ResyncMFADeviceWithContext mocks base method +func (m *MockIAMAPI) ResyncMFADeviceWithContext(arg0 context.Context, arg1 *iam.ResyncMFADeviceInput, arg2 ...request.Option) (*iam.ResyncMFADeviceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResyncMFADeviceWithContext", varargs...) + ret0, _ := ret[0].(*iam.ResyncMFADeviceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResyncMFADeviceWithContext indicates an expected call of ResyncMFADeviceWithContext +func (mr *MockIAMAPIMockRecorder) ResyncMFADeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResyncMFADeviceWithContext", reflect.TypeOf((*MockIAMAPI)(nil).ResyncMFADeviceWithContext), varargs...) +} + +// SetDefaultPolicyVersion mocks base method +func (m *MockIAMAPI) SetDefaultPolicyVersion(arg0 *iam.SetDefaultPolicyVersionInput) (*iam.SetDefaultPolicyVersionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDefaultPolicyVersion", arg0) + ret0, _ := ret[0].(*iam.SetDefaultPolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetDefaultPolicyVersion indicates an expected call of SetDefaultPolicyVersion +func (mr *MockIAMAPIMockRecorder) SetDefaultPolicyVersion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultPolicyVersion", reflect.TypeOf((*MockIAMAPI)(nil).SetDefaultPolicyVersion), arg0) +} + +// SetDefaultPolicyVersionRequest mocks base method +func (m *MockIAMAPI) SetDefaultPolicyVersionRequest(arg0 *iam.SetDefaultPolicyVersionInput) (*request.Request, *iam.SetDefaultPolicyVersionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDefaultPolicyVersionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.SetDefaultPolicyVersionOutput) + return ret0, ret1 +} + +// SetDefaultPolicyVersionRequest indicates an expected call of SetDefaultPolicyVersionRequest +func (mr *MockIAMAPIMockRecorder) SetDefaultPolicyVersionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultPolicyVersionRequest", reflect.TypeOf((*MockIAMAPI)(nil).SetDefaultPolicyVersionRequest), arg0) +} + +// SetDefaultPolicyVersionWithContext mocks base method +func (m *MockIAMAPI) SetDefaultPolicyVersionWithContext(arg0 context.Context, arg1 *iam.SetDefaultPolicyVersionInput, arg2 ...request.Option) (*iam.SetDefaultPolicyVersionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetDefaultPolicyVersionWithContext", varargs...) + ret0, _ := ret[0].(*iam.SetDefaultPolicyVersionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetDefaultPolicyVersionWithContext indicates an expected call of SetDefaultPolicyVersionWithContext +func (mr *MockIAMAPIMockRecorder) SetDefaultPolicyVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultPolicyVersionWithContext", reflect.TypeOf((*MockIAMAPI)(nil).SetDefaultPolicyVersionWithContext), varargs...) +} + +// SetSecurityTokenServicePreferences mocks base method +func (m *MockIAMAPI) SetSecurityTokenServicePreferences(arg0 *iam.SetSecurityTokenServicePreferencesInput) (*iam.SetSecurityTokenServicePreferencesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSecurityTokenServicePreferences", arg0) + ret0, _ := ret[0].(*iam.SetSecurityTokenServicePreferencesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetSecurityTokenServicePreferences indicates an expected call of SetSecurityTokenServicePreferences +func (mr *MockIAMAPIMockRecorder) SetSecurityTokenServicePreferences(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityTokenServicePreferences", reflect.TypeOf((*MockIAMAPI)(nil).SetSecurityTokenServicePreferences), arg0) +} + +// SetSecurityTokenServicePreferencesRequest mocks base method +func (m *MockIAMAPI) SetSecurityTokenServicePreferencesRequest(arg0 *iam.SetSecurityTokenServicePreferencesInput) (*request.Request, *iam.SetSecurityTokenServicePreferencesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSecurityTokenServicePreferencesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.SetSecurityTokenServicePreferencesOutput) + return ret0, ret1 +} + +// SetSecurityTokenServicePreferencesRequest indicates an expected call of SetSecurityTokenServicePreferencesRequest +func (mr *MockIAMAPIMockRecorder) SetSecurityTokenServicePreferencesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityTokenServicePreferencesRequest", reflect.TypeOf((*MockIAMAPI)(nil).SetSecurityTokenServicePreferencesRequest), arg0) +} + +// SetSecurityTokenServicePreferencesWithContext mocks base method +func (m *MockIAMAPI) SetSecurityTokenServicePreferencesWithContext(arg0 context.Context, arg1 *iam.SetSecurityTokenServicePreferencesInput, arg2 ...request.Option) (*iam.SetSecurityTokenServicePreferencesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetSecurityTokenServicePreferencesWithContext", varargs...) + ret0, _ := ret[0].(*iam.SetSecurityTokenServicePreferencesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetSecurityTokenServicePreferencesWithContext indicates an expected call of SetSecurityTokenServicePreferencesWithContext +func (mr *MockIAMAPIMockRecorder) SetSecurityTokenServicePreferencesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityTokenServicePreferencesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).SetSecurityTokenServicePreferencesWithContext), varargs...) +} + +// SimulateCustomPolicy mocks base method +func (m *MockIAMAPI) SimulateCustomPolicy(arg0 *iam.SimulateCustomPolicyInput) (*iam.SimulatePolicyResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SimulateCustomPolicy", arg0) + ret0, _ := ret[0].(*iam.SimulatePolicyResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SimulateCustomPolicy indicates an expected call of SimulateCustomPolicy +func (mr *MockIAMAPIMockRecorder) SimulateCustomPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulateCustomPolicy", reflect.TypeOf((*MockIAMAPI)(nil).SimulateCustomPolicy), arg0) +} + +// SimulateCustomPolicyPages mocks base method +func (m *MockIAMAPI) SimulateCustomPolicyPages(arg0 *iam.SimulateCustomPolicyInput, arg1 func(*iam.SimulatePolicyResponse, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SimulateCustomPolicyPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SimulateCustomPolicyPages indicates an expected call of SimulateCustomPolicyPages +func (mr *MockIAMAPIMockRecorder) SimulateCustomPolicyPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulateCustomPolicyPages", reflect.TypeOf((*MockIAMAPI)(nil).SimulateCustomPolicyPages), arg0, arg1) +} + +// SimulateCustomPolicyPagesWithContext mocks base method +func (m *MockIAMAPI) SimulateCustomPolicyPagesWithContext(arg0 context.Context, arg1 *iam.SimulateCustomPolicyInput, arg2 func(*iam.SimulatePolicyResponse, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SimulateCustomPolicyPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SimulateCustomPolicyPagesWithContext indicates an expected call of SimulateCustomPolicyPagesWithContext +func (mr *MockIAMAPIMockRecorder) SimulateCustomPolicyPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulateCustomPolicyPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).SimulateCustomPolicyPagesWithContext), varargs...) +} + +// SimulateCustomPolicyRequest mocks base method +func (m *MockIAMAPI) SimulateCustomPolicyRequest(arg0 *iam.SimulateCustomPolicyInput) (*request.Request, *iam.SimulatePolicyResponse) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SimulateCustomPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.SimulatePolicyResponse) + return ret0, ret1 +} + +// SimulateCustomPolicyRequest indicates an expected call of SimulateCustomPolicyRequest +func (mr *MockIAMAPIMockRecorder) SimulateCustomPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulateCustomPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).SimulateCustomPolicyRequest), arg0) +} + +// SimulateCustomPolicyWithContext mocks base method +func (m *MockIAMAPI) SimulateCustomPolicyWithContext(arg0 context.Context, arg1 *iam.SimulateCustomPolicyInput, arg2 ...request.Option) (*iam.SimulatePolicyResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SimulateCustomPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.SimulatePolicyResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SimulateCustomPolicyWithContext indicates an expected call of SimulateCustomPolicyWithContext +func (mr *MockIAMAPIMockRecorder) SimulateCustomPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulateCustomPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).SimulateCustomPolicyWithContext), varargs...) +} + +// SimulatePrincipalPolicy mocks base method +func (m *MockIAMAPI) SimulatePrincipalPolicy(arg0 *iam.SimulatePrincipalPolicyInput) (*iam.SimulatePolicyResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SimulatePrincipalPolicy", arg0) + ret0, _ := ret[0].(*iam.SimulatePolicyResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SimulatePrincipalPolicy indicates an expected call of SimulatePrincipalPolicy +func (mr *MockIAMAPIMockRecorder) SimulatePrincipalPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulatePrincipalPolicy", reflect.TypeOf((*MockIAMAPI)(nil).SimulatePrincipalPolicy), arg0) +} + +// SimulatePrincipalPolicyPages mocks base method +func (m *MockIAMAPI) SimulatePrincipalPolicyPages(arg0 *iam.SimulatePrincipalPolicyInput, arg1 func(*iam.SimulatePolicyResponse, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SimulatePrincipalPolicyPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SimulatePrincipalPolicyPages indicates an expected call of SimulatePrincipalPolicyPages +func (mr *MockIAMAPIMockRecorder) SimulatePrincipalPolicyPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulatePrincipalPolicyPages", reflect.TypeOf((*MockIAMAPI)(nil).SimulatePrincipalPolicyPages), arg0, arg1) +} + +// SimulatePrincipalPolicyPagesWithContext mocks base method +func (m *MockIAMAPI) SimulatePrincipalPolicyPagesWithContext(arg0 context.Context, arg1 *iam.SimulatePrincipalPolicyInput, arg2 func(*iam.SimulatePolicyResponse, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SimulatePrincipalPolicyPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SimulatePrincipalPolicyPagesWithContext indicates an expected call of SimulatePrincipalPolicyPagesWithContext +func (mr *MockIAMAPIMockRecorder) SimulatePrincipalPolicyPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulatePrincipalPolicyPagesWithContext", reflect.TypeOf((*MockIAMAPI)(nil).SimulatePrincipalPolicyPagesWithContext), varargs...) +} + +// SimulatePrincipalPolicyRequest mocks base method +func (m *MockIAMAPI) SimulatePrincipalPolicyRequest(arg0 *iam.SimulatePrincipalPolicyInput) (*request.Request, *iam.SimulatePolicyResponse) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SimulatePrincipalPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.SimulatePolicyResponse) + return ret0, ret1 +} + +// SimulatePrincipalPolicyRequest indicates an expected call of SimulatePrincipalPolicyRequest +func (mr *MockIAMAPIMockRecorder) SimulatePrincipalPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulatePrincipalPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).SimulatePrincipalPolicyRequest), arg0) +} + +// SimulatePrincipalPolicyWithContext mocks base method +func (m *MockIAMAPI) SimulatePrincipalPolicyWithContext(arg0 context.Context, arg1 *iam.SimulatePrincipalPolicyInput, arg2 ...request.Option) (*iam.SimulatePolicyResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SimulatePrincipalPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.SimulatePolicyResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SimulatePrincipalPolicyWithContext indicates an expected call of SimulatePrincipalPolicyWithContext +func (mr *MockIAMAPIMockRecorder) SimulatePrincipalPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SimulatePrincipalPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).SimulatePrincipalPolicyWithContext), varargs...) +} + +// TagRole mocks base method +func (m *MockIAMAPI) TagRole(arg0 *iam.TagRoleInput) (*iam.TagRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagRole", arg0) + ret0, _ := ret[0].(*iam.TagRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagRole indicates an expected call of TagRole +func (mr *MockIAMAPIMockRecorder) TagRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagRole", reflect.TypeOf((*MockIAMAPI)(nil).TagRole), arg0) +} + +// TagRoleRequest mocks base method +func (m *MockIAMAPI) TagRoleRequest(arg0 *iam.TagRoleInput) (*request.Request, *iam.TagRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.TagRoleOutput) + return ret0, ret1 +} + +// TagRoleRequest indicates an expected call of TagRoleRequest +func (mr *MockIAMAPIMockRecorder) TagRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).TagRoleRequest), arg0) +} + +// TagRoleWithContext mocks base method +func (m *MockIAMAPI) TagRoleWithContext(arg0 context.Context, arg1 *iam.TagRoleInput, arg2 ...request.Option) (*iam.TagRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.TagRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagRoleWithContext indicates an expected call of TagRoleWithContext +func (mr *MockIAMAPIMockRecorder) TagRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).TagRoleWithContext), varargs...) +} + +// TagUser mocks base method +func (m *MockIAMAPI) TagUser(arg0 *iam.TagUserInput) (*iam.TagUserOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagUser", arg0) + ret0, _ := ret[0].(*iam.TagUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagUser indicates an expected call of TagUser +func (mr *MockIAMAPIMockRecorder) TagUser(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagUser", reflect.TypeOf((*MockIAMAPI)(nil).TagUser), arg0) +} + +// TagUserRequest mocks base method +func (m *MockIAMAPI) TagUserRequest(arg0 *iam.TagUserInput) (*request.Request, *iam.TagUserOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagUserRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.TagUserOutput) + return ret0, ret1 +} + +// TagUserRequest indicates an expected call of TagUserRequest +func (mr *MockIAMAPIMockRecorder) TagUserRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagUserRequest", reflect.TypeOf((*MockIAMAPI)(nil).TagUserRequest), arg0) +} + +// TagUserWithContext mocks base method +func (m *MockIAMAPI) TagUserWithContext(arg0 context.Context, arg1 *iam.TagUserInput, arg2 ...request.Option) (*iam.TagUserOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagUserWithContext", varargs...) + ret0, _ := ret[0].(*iam.TagUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagUserWithContext indicates an expected call of TagUserWithContext +func (mr *MockIAMAPIMockRecorder) TagUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagUserWithContext", reflect.TypeOf((*MockIAMAPI)(nil).TagUserWithContext), varargs...) +} + +// UntagRole mocks base method +func (m *MockIAMAPI) UntagRole(arg0 *iam.UntagRoleInput) (*iam.UntagRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagRole", arg0) + ret0, _ := ret[0].(*iam.UntagRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagRole indicates an expected call of UntagRole +func (mr *MockIAMAPIMockRecorder) UntagRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagRole", reflect.TypeOf((*MockIAMAPI)(nil).UntagRole), arg0) +} + +// UntagRoleRequest mocks base method +func (m *MockIAMAPI) UntagRoleRequest(arg0 *iam.UntagRoleInput) (*request.Request, *iam.UntagRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UntagRoleOutput) + return ret0, ret1 +} + +// UntagRoleRequest indicates an expected call of UntagRoleRequest +func (mr *MockIAMAPIMockRecorder) UntagRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).UntagRoleRequest), arg0) +} + +// UntagRoleWithContext mocks base method +func (m *MockIAMAPI) UntagRoleWithContext(arg0 context.Context, arg1 *iam.UntagRoleInput, arg2 ...request.Option) (*iam.UntagRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.UntagRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagRoleWithContext indicates an expected call of UntagRoleWithContext +func (mr *MockIAMAPIMockRecorder) UntagRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UntagRoleWithContext), varargs...) +} + +// UntagUser mocks base method +func (m *MockIAMAPI) UntagUser(arg0 *iam.UntagUserInput) (*iam.UntagUserOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagUser", arg0) + ret0, _ := ret[0].(*iam.UntagUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagUser indicates an expected call of UntagUser +func (mr *MockIAMAPIMockRecorder) UntagUser(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagUser", reflect.TypeOf((*MockIAMAPI)(nil).UntagUser), arg0) +} + +// UntagUserRequest mocks base method +func (m *MockIAMAPI) UntagUserRequest(arg0 *iam.UntagUserInput) (*request.Request, *iam.UntagUserOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagUserRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UntagUserOutput) + return ret0, ret1 +} + +// UntagUserRequest indicates an expected call of UntagUserRequest +func (mr *MockIAMAPIMockRecorder) UntagUserRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagUserRequest", reflect.TypeOf((*MockIAMAPI)(nil).UntagUserRequest), arg0) +} + +// UntagUserWithContext mocks base method +func (m *MockIAMAPI) UntagUserWithContext(arg0 context.Context, arg1 *iam.UntagUserInput, arg2 ...request.Option) (*iam.UntagUserOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagUserWithContext", varargs...) + ret0, _ := ret[0].(*iam.UntagUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagUserWithContext indicates an expected call of UntagUserWithContext +func (mr *MockIAMAPIMockRecorder) UntagUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagUserWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UntagUserWithContext), varargs...) +} + +// UpdateAccessKey mocks base method +func (m *MockIAMAPI) UpdateAccessKey(arg0 *iam.UpdateAccessKeyInput) (*iam.UpdateAccessKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAccessKey", arg0) + ret0, _ := ret[0].(*iam.UpdateAccessKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAccessKey indicates an expected call of UpdateAccessKey +func (mr *MockIAMAPIMockRecorder) UpdateAccessKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccessKey", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAccessKey), arg0) +} + +// UpdateAccessKeyRequest mocks base method +func (m *MockIAMAPI) UpdateAccessKeyRequest(arg0 *iam.UpdateAccessKeyInput) (*request.Request, *iam.UpdateAccessKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAccessKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateAccessKeyOutput) + return ret0, ret1 +} + +// UpdateAccessKeyRequest indicates an expected call of UpdateAccessKeyRequest +func (mr *MockIAMAPIMockRecorder) UpdateAccessKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccessKeyRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAccessKeyRequest), arg0) +} + +// UpdateAccessKeyWithContext mocks base method +func (m *MockIAMAPI) UpdateAccessKeyWithContext(arg0 context.Context, arg1 *iam.UpdateAccessKeyInput, arg2 ...request.Option) (*iam.UpdateAccessKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateAccessKeyWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateAccessKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAccessKeyWithContext indicates an expected call of UpdateAccessKeyWithContext +func (mr *MockIAMAPIMockRecorder) UpdateAccessKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccessKeyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAccessKeyWithContext), varargs...) +} + +// UpdateAccountPasswordPolicy mocks base method +func (m *MockIAMAPI) UpdateAccountPasswordPolicy(arg0 *iam.UpdateAccountPasswordPolicyInput) (*iam.UpdateAccountPasswordPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAccountPasswordPolicy", arg0) + ret0, _ := ret[0].(*iam.UpdateAccountPasswordPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAccountPasswordPolicy indicates an expected call of UpdateAccountPasswordPolicy +func (mr *MockIAMAPIMockRecorder) UpdateAccountPasswordPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccountPasswordPolicy", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAccountPasswordPolicy), arg0) +} + +// UpdateAccountPasswordPolicyRequest mocks base method +func (m *MockIAMAPI) UpdateAccountPasswordPolicyRequest(arg0 *iam.UpdateAccountPasswordPolicyInput) (*request.Request, *iam.UpdateAccountPasswordPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAccountPasswordPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateAccountPasswordPolicyOutput) + return ret0, ret1 +} + +// UpdateAccountPasswordPolicyRequest indicates an expected call of UpdateAccountPasswordPolicyRequest +func (mr *MockIAMAPIMockRecorder) UpdateAccountPasswordPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccountPasswordPolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAccountPasswordPolicyRequest), arg0) +} + +// UpdateAccountPasswordPolicyWithContext mocks base method +func (m *MockIAMAPI) UpdateAccountPasswordPolicyWithContext(arg0 context.Context, arg1 *iam.UpdateAccountPasswordPolicyInput, arg2 ...request.Option) (*iam.UpdateAccountPasswordPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateAccountPasswordPolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateAccountPasswordPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAccountPasswordPolicyWithContext indicates an expected call of UpdateAccountPasswordPolicyWithContext +func (mr *MockIAMAPIMockRecorder) UpdateAccountPasswordPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccountPasswordPolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAccountPasswordPolicyWithContext), varargs...) +} + +// UpdateAssumeRolePolicy mocks base method +func (m *MockIAMAPI) UpdateAssumeRolePolicy(arg0 *iam.UpdateAssumeRolePolicyInput) (*iam.UpdateAssumeRolePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAssumeRolePolicy", arg0) + ret0, _ := ret[0].(*iam.UpdateAssumeRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAssumeRolePolicy indicates an expected call of UpdateAssumeRolePolicy +func (mr *MockIAMAPIMockRecorder) UpdateAssumeRolePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssumeRolePolicy", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAssumeRolePolicy), arg0) +} + +// UpdateAssumeRolePolicyRequest mocks base method +func (m *MockIAMAPI) UpdateAssumeRolePolicyRequest(arg0 *iam.UpdateAssumeRolePolicyInput) (*request.Request, *iam.UpdateAssumeRolePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAssumeRolePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateAssumeRolePolicyOutput) + return ret0, ret1 +} + +// UpdateAssumeRolePolicyRequest indicates an expected call of UpdateAssumeRolePolicyRequest +func (mr *MockIAMAPIMockRecorder) UpdateAssumeRolePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssumeRolePolicyRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAssumeRolePolicyRequest), arg0) +} + +// UpdateAssumeRolePolicyWithContext mocks base method +func (m *MockIAMAPI) UpdateAssumeRolePolicyWithContext(arg0 context.Context, arg1 *iam.UpdateAssumeRolePolicyInput, arg2 ...request.Option) (*iam.UpdateAssumeRolePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateAssumeRolePolicyWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateAssumeRolePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAssumeRolePolicyWithContext indicates an expected call of UpdateAssumeRolePolicyWithContext +func (mr *MockIAMAPIMockRecorder) UpdateAssumeRolePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssumeRolePolicyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateAssumeRolePolicyWithContext), varargs...) +} + +// UpdateGroup mocks base method +func (m *MockIAMAPI) UpdateGroup(arg0 *iam.UpdateGroupInput) (*iam.UpdateGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGroup", arg0) + ret0, _ := ret[0].(*iam.UpdateGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGroup indicates an expected call of UpdateGroup +func (mr *MockIAMAPIMockRecorder) UpdateGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroup", reflect.TypeOf((*MockIAMAPI)(nil).UpdateGroup), arg0) +} + +// UpdateGroupRequest mocks base method +func (m *MockIAMAPI) UpdateGroupRequest(arg0 *iam.UpdateGroupInput) (*request.Request, *iam.UpdateGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateGroupOutput) + return ret0, ret1 +} + +// UpdateGroupRequest indicates an expected call of UpdateGroupRequest +func (mr *MockIAMAPIMockRecorder) UpdateGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroupRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateGroupRequest), arg0) +} + +// UpdateGroupWithContext mocks base method +func (m *MockIAMAPI) UpdateGroupWithContext(arg0 context.Context, arg1 *iam.UpdateGroupInput, arg2 ...request.Option) (*iam.UpdateGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateGroupWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateGroupWithContext indicates an expected call of UpdateGroupWithContext +func (mr *MockIAMAPIMockRecorder) UpdateGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroupWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateGroupWithContext), varargs...) +} + +// UpdateLoginProfile mocks base method +func (m *MockIAMAPI) UpdateLoginProfile(arg0 *iam.UpdateLoginProfileInput) (*iam.UpdateLoginProfileOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateLoginProfile", arg0) + ret0, _ := ret[0].(*iam.UpdateLoginProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateLoginProfile indicates an expected call of UpdateLoginProfile +func (mr *MockIAMAPIMockRecorder) UpdateLoginProfile(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLoginProfile", reflect.TypeOf((*MockIAMAPI)(nil).UpdateLoginProfile), arg0) +} + +// UpdateLoginProfileRequest mocks base method +func (m *MockIAMAPI) UpdateLoginProfileRequest(arg0 *iam.UpdateLoginProfileInput) (*request.Request, *iam.UpdateLoginProfileOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateLoginProfileRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateLoginProfileOutput) + return ret0, ret1 +} + +// UpdateLoginProfileRequest indicates an expected call of UpdateLoginProfileRequest +func (mr *MockIAMAPIMockRecorder) UpdateLoginProfileRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLoginProfileRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateLoginProfileRequest), arg0) +} + +// UpdateLoginProfileWithContext mocks base method +func (m *MockIAMAPI) UpdateLoginProfileWithContext(arg0 context.Context, arg1 *iam.UpdateLoginProfileInput, arg2 ...request.Option) (*iam.UpdateLoginProfileOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateLoginProfileWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateLoginProfileOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateLoginProfileWithContext indicates an expected call of UpdateLoginProfileWithContext +func (mr *MockIAMAPIMockRecorder) UpdateLoginProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLoginProfileWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateLoginProfileWithContext), varargs...) +} + +// UpdateOpenIDConnectProviderThumbprint mocks base method +func (m *MockIAMAPI) UpdateOpenIDConnectProviderThumbprint(arg0 *iam.UpdateOpenIDConnectProviderThumbprintInput) (*iam.UpdateOpenIDConnectProviderThumbprintOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateOpenIDConnectProviderThumbprint", arg0) + ret0, _ := ret[0].(*iam.UpdateOpenIDConnectProviderThumbprintOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateOpenIDConnectProviderThumbprint indicates an expected call of UpdateOpenIDConnectProviderThumbprint +func (mr *MockIAMAPIMockRecorder) UpdateOpenIDConnectProviderThumbprint(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpenIDConnectProviderThumbprint", reflect.TypeOf((*MockIAMAPI)(nil).UpdateOpenIDConnectProviderThumbprint), arg0) +} + +// UpdateOpenIDConnectProviderThumbprintRequest mocks base method +func (m *MockIAMAPI) UpdateOpenIDConnectProviderThumbprintRequest(arg0 *iam.UpdateOpenIDConnectProviderThumbprintInput) (*request.Request, *iam.UpdateOpenIDConnectProviderThumbprintOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateOpenIDConnectProviderThumbprintRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateOpenIDConnectProviderThumbprintOutput) + return ret0, ret1 +} + +// UpdateOpenIDConnectProviderThumbprintRequest indicates an expected call of UpdateOpenIDConnectProviderThumbprintRequest +func (mr *MockIAMAPIMockRecorder) UpdateOpenIDConnectProviderThumbprintRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpenIDConnectProviderThumbprintRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateOpenIDConnectProviderThumbprintRequest), arg0) +} + +// UpdateOpenIDConnectProviderThumbprintWithContext mocks base method +func (m *MockIAMAPI) UpdateOpenIDConnectProviderThumbprintWithContext(arg0 context.Context, arg1 *iam.UpdateOpenIDConnectProviderThumbprintInput, arg2 ...request.Option) (*iam.UpdateOpenIDConnectProviderThumbprintOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateOpenIDConnectProviderThumbprintWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateOpenIDConnectProviderThumbprintOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateOpenIDConnectProviderThumbprintWithContext indicates an expected call of UpdateOpenIDConnectProviderThumbprintWithContext +func (mr *MockIAMAPIMockRecorder) UpdateOpenIDConnectProviderThumbprintWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpenIDConnectProviderThumbprintWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateOpenIDConnectProviderThumbprintWithContext), varargs...) +} + +// UpdateRole mocks base method +func (m *MockIAMAPI) UpdateRole(arg0 *iam.UpdateRoleInput) (*iam.UpdateRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRole", arg0) + ret0, _ := ret[0].(*iam.UpdateRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateRole indicates an expected call of UpdateRole +func (mr *MockIAMAPIMockRecorder) UpdateRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRole", reflect.TypeOf((*MockIAMAPI)(nil).UpdateRole), arg0) +} + +// UpdateRoleDescription mocks base method +func (m *MockIAMAPI) UpdateRoleDescription(arg0 *iam.UpdateRoleDescriptionInput) (*iam.UpdateRoleDescriptionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRoleDescription", arg0) + ret0, _ := ret[0].(*iam.UpdateRoleDescriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateRoleDescription indicates an expected call of UpdateRoleDescription +func (mr *MockIAMAPIMockRecorder) UpdateRoleDescription(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleDescription", reflect.TypeOf((*MockIAMAPI)(nil).UpdateRoleDescription), arg0) +} + +// UpdateRoleDescriptionRequest mocks base method +func (m *MockIAMAPI) UpdateRoleDescriptionRequest(arg0 *iam.UpdateRoleDescriptionInput) (*request.Request, *iam.UpdateRoleDescriptionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRoleDescriptionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateRoleDescriptionOutput) + return ret0, ret1 +} + +// UpdateRoleDescriptionRequest indicates an expected call of UpdateRoleDescriptionRequest +func (mr *MockIAMAPIMockRecorder) UpdateRoleDescriptionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleDescriptionRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateRoleDescriptionRequest), arg0) +} + +// UpdateRoleDescriptionWithContext mocks base method +func (m *MockIAMAPI) UpdateRoleDescriptionWithContext(arg0 context.Context, arg1 *iam.UpdateRoleDescriptionInput, arg2 ...request.Option) (*iam.UpdateRoleDescriptionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateRoleDescriptionWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateRoleDescriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateRoleDescriptionWithContext indicates an expected call of UpdateRoleDescriptionWithContext +func (mr *MockIAMAPIMockRecorder) UpdateRoleDescriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleDescriptionWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateRoleDescriptionWithContext), varargs...) +} + +// UpdateRoleRequest mocks base method +func (m *MockIAMAPI) UpdateRoleRequest(arg0 *iam.UpdateRoleInput) (*request.Request, *iam.UpdateRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateRoleOutput) + return ret0, ret1 +} + +// UpdateRoleRequest indicates an expected call of UpdateRoleRequest +func (mr *MockIAMAPIMockRecorder) UpdateRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateRoleRequest), arg0) +} + +// UpdateRoleWithContext mocks base method +func (m *MockIAMAPI) UpdateRoleWithContext(arg0 context.Context, arg1 *iam.UpdateRoleInput, arg2 ...request.Option) (*iam.UpdateRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateRoleWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateRoleWithContext indicates an expected call of UpdateRoleWithContext +func (mr *MockIAMAPIMockRecorder) UpdateRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateRoleWithContext), varargs...) +} + +// UpdateSAMLProvider mocks base method +func (m *MockIAMAPI) UpdateSAMLProvider(arg0 *iam.UpdateSAMLProviderInput) (*iam.UpdateSAMLProviderOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSAMLProvider", arg0) + ret0, _ := ret[0].(*iam.UpdateSAMLProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSAMLProvider indicates an expected call of UpdateSAMLProvider +func (mr *MockIAMAPIMockRecorder) UpdateSAMLProvider(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSAMLProvider", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSAMLProvider), arg0) +} + +// UpdateSAMLProviderRequest mocks base method +func (m *MockIAMAPI) UpdateSAMLProviderRequest(arg0 *iam.UpdateSAMLProviderInput) (*request.Request, *iam.UpdateSAMLProviderOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSAMLProviderRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateSAMLProviderOutput) + return ret0, ret1 +} + +// UpdateSAMLProviderRequest indicates an expected call of UpdateSAMLProviderRequest +func (mr *MockIAMAPIMockRecorder) UpdateSAMLProviderRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSAMLProviderRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSAMLProviderRequest), arg0) +} + +// UpdateSAMLProviderWithContext mocks base method +func (m *MockIAMAPI) UpdateSAMLProviderWithContext(arg0 context.Context, arg1 *iam.UpdateSAMLProviderInput, arg2 ...request.Option) (*iam.UpdateSAMLProviderOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateSAMLProviderWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateSAMLProviderOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSAMLProviderWithContext indicates an expected call of UpdateSAMLProviderWithContext +func (mr *MockIAMAPIMockRecorder) UpdateSAMLProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSAMLProviderWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSAMLProviderWithContext), varargs...) +} + +// UpdateSSHPublicKey mocks base method +func (m *MockIAMAPI) UpdateSSHPublicKey(arg0 *iam.UpdateSSHPublicKeyInput) (*iam.UpdateSSHPublicKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSSHPublicKey", arg0) + ret0, _ := ret[0].(*iam.UpdateSSHPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSSHPublicKey indicates an expected call of UpdateSSHPublicKey +func (mr *MockIAMAPIMockRecorder) UpdateSSHPublicKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSSHPublicKey", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSSHPublicKey), arg0) +} + +// UpdateSSHPublicKeyRequest mocks base method +func (m *MockIAMAPI) UpdateSSHPublicKeyRequest(arg0 *iam.UpdateSSHPublicKeyInput) (*request.Request, *iam.UpdateSSHPublicKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSSHPublicKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateSSHPublicKeyOutput) + return ret0, ret1 +} + +// UpdateSSHPublicKeyRequest indicates an expected call of UpdateSSHPublicKeyRequest +func (mr *MockIAMAPIMockRecorder) UpdateSSHPublicKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSSHPublicKeyRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSSHPublicKeyRequest), arg0) +} + +// UpdateSSHPublicKeyWithContext mocks base method +func (m *MockIAMAPI) UpdateSSHPublicKeyWithContext(arg0 context.Context, arg1 *iam.UpdateSSHPublicKeyInput, arg2 ...request.Option) (*iam.UpdateSSHPublicKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateSSHPublicKeyWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateSSHPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSSHPublicKeyWithContext indicates an expected call of UpdateSSHPublicKeyWithContext +func (mr *MockIAMAPIMockRecorder) UpdateSSHPublicKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSSHPublicKeyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSSHPublicKeyWithContext), varargs...) +} + +// UpdateServerCertificate mocks base method +func (m *MockIAMAPI) UpdateServerCertificate(arg0 *iam.UpdateServerCertificateInput) (*iam.UpdateServerCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateServerCertificate", arg0) + ret0, _ := ret[0].(*iam.UpdateServerCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateServerCertificate indicates an expected call of UpdateServerCertificate +func (mr *MockIAMAPIMockRecorder) UpdateServerCertificate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServerCertificate", reflect.TypeOf((*MockIAMAPI)(nil).UpdateServerCertificate), arg0) +} + +// UpdateServerCertificateRequest mocks base method +func (m *MockIAMAPI) UpdateServerCertificateRequest(arg0 *iam.UpdateServerCertificateInput) (*request.Request, *iam.UpdateServerCertificateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateServerCertificateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateServerCertificateOutput) + return ret0, ret1 +} + +// UpdateServerCertificateRequest indicates an expected call of UpdateServerCertificateRequest +func (mr *MockIAMAPIMockRecorder) UpdateServerCertificateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServerCertificateRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateServerCertificateRequest), arg0) +} + +// UpdateServerCertificateWithContext mocks base method +func (m *MockIAMAPI) UpdateServerCertificateWithContext(arg0 context.Context, arg1 *iam.UpdateServerCertificateInput, arg2 ...request.Option) (*iam.UpdateServerCertificateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateServerCertificateWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateServerCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateServerCertificateWithContext indicates an expected call of UpdateServerCertificateWithContext +func (mr *MockIAMAPIMockRecorder) UpdateServerCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServerCertificateWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateServerCertificateWithContext), varargs...) +} + +// UpdateServiceSpecificCredential mocks base method +func (m *MockIAMAPI) UpdateServiceSpecificCredential(arg0 *iam.UpdateServiceSpecificCredentialInput) (*iam.UpdateServiceSpecificCredentialOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateServiceSpecificCredential", arg0) + ret0, _ := ret[0].(*iam.UpdateServiceSpecificCredentialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateServiceSpecificCredential indicates an expected call of UpdateServiceSpecificCredential +func (mr *MockIAMAPIMockRecorder) UpdateServiceSpecificCredential(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceSpecificCredential", reflect.TypeOf((*MockIAMAPI)(nil).UpdateServiceSpecificCredential), arg0) +} + +// UpdateServiceSpecificCredentialRequest mocks base method +func (m *MockIAMAPI) UpdateServiceSpecificCredentialRequest(arg0 *iam.UpdateServiceSpecificCredentialInput) (*request.Request, *iam.UpdateServiceSpecificCredentialOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateServiceSpecificCredentialRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateServiceSpecificCredentialOutput) + return ret0, ret1 +} + +// UpdateServiceSpecificCredentialRequest indicates an expected call of UpdateServiceSpecificCredentialRequest +func (mr *MockIAMAPIMockRecorder) UpdateServiceSpecificCredentialRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceSpecificCredentialRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateServiceSpecificCredentialRequest), arg0) +} + +// UpdateServiceSpecificCredentialWithContext mocks base method +func (m *MockIAMAPI) UpdateServiceSpecificCredentialWithContext(arg0 context.Context, arg1 *iam.UpdateServiceSpecificCredentialInput, arg2 ...request.Option) (*iam.UpdateServiceSpecificCredentialOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateServiceSpecificCredentialWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateServiceSpecificCredentialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateServiceSpecificCredentialWithContext indicates an expected call of UpdateServiceSpecificCredentialWithContext +func (mr *MockIAMAPIMockRecorder) UpdateServiceSpecificCredentialWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceSpecificCredentialWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateServiceSpecificCredentialWithContext), varargs...) +} + +// UpdateSigningCertificate mocks base method +func (m *MockIAMAPI) UpdateSigningCertificate(arg0 *iam.UpdateSigningCertificateInput) (*iam.UpdateSigningCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSigningCertificate", arg0) + ret0, _ := ret[0].(*iam.UpdateSigningCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSigningCertificate indicates an expected call of UpdateSigningCertificate +func (mr *MockIAMAPIMockRecorder) UpdateSigningCertificate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSigningCertificate", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSigningCertificate), arg0) +} + +// UpdateSigningCertificateRequest mocks base method +func (m *MockIAMAPI) UpdateSigningCertificateRequest(arg0 *iam.UpdateSigningCertificateInput) (*request.Request, *iam.UpdateSigningCertificateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateSigningCertificateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateSigningCertificateOutput) + return ret0, ret1 +} + +// UpdateSigningCertificateRequest indicates an expected call of UpdateSigningCertificateRequest +func (mr *MockIAMAPIMockRecorder) UpdateSigningCertificateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSigningCertificateRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSigningCertificateRequest), arg0) +} + +// UpdateSigningCertificateWithContext mocks base method +func (m *MockIAMAPI) UpdateSigningCertificateWithContext(arg0 context.Context, arg1 *iam.UpdateSigningCertificateInput, arg2 ...request.Option) (*iam.UpdateSigningCertificateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateSigningCertificateWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateSigningCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateSigningCertificateWithContext indicates an expected call of UpdateSigningCertificateWithContext +func (mr *MockIAMAPIMockRecorder) UpdateSigningCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSigningCertificateWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateSigningCertificateWithContext), varargs...) +} + +// UpdateUser mocks base method +func (m *MockIAMAPI) UpdateUser(arg0 *iam.UpdateUserInput) (*iam.UpdateUserOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateUser", arg0) + ret0, _ := ret[0].(*iam.UpdateUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateUser indicates an expected call of UpdateUser +func (mr *MockIAMAPIMockRecorder) UpdateUser(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockIAMAPI)(nil).UpdateUser), arg0) +} + +// UpdateUserRequest mocks base method +func (m *MockIAMAPI) UpdateUserRequest(arg0 *iam.UpdateUserInput) (*request.Request, *iam.UpdateUserOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateUserRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UpdateUserOutput) + return ret0, ret1 +} + +// UpdateUserRequest indicates an expected call of UpdateUserRequest +func (mr *MockIAMAPIMockRecorder) UpdateUserRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserRequest", reflect.TypeOf((*MockIAMAPI)(nil).UpdateUserRequest), arg0) +} + +// UpdateUserWithContext mocks base method +func (m *MockIAMAPI) UpdateUserWithContext(arg0 context.Context, arg1 *iam.UpdateUserInput, arg2 ...request.Option) (*iam.UpdateUserOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateUserWithContext", varargs...) + ret0, _ := ret[0].(*iam.UpdateUserOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateUserWithContext indicates an expected call of UpdateUserWithContext +func (mr *MockIAMAPIMockRecorder) UpdateUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UpdateUserWithContext), varargs...) +} + +// UploadSSHPublicKey mocks base method +func (m *MockIAMAPI) UploadSSHPublicKey(arg0 *iam.UploadSSHPublicKeyInput) (*iam.UploadSSHPublicKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UploadSSHPublicKey", arg0) + ret0, _ := ret[0].(*iam.UploadSSHPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadSSHPublicKey indicates an expected call of UploadSSHPublicKey +func (mr *MockIAMAPIMockRecorder) UploadSSHPublicKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadSSHPublicKey", reflect.TypeOf((*MockIAMAPI)(nil).UploadSSHPublicKey), arg0) +} + +// UploadSSHPublicKeyRequest mocks base method +func (m *MockIAMAPI) UploadSSHPublicKeyRequest(arg0 *iam.UploadSSHPublicKeyInput) (*request.Request, *iam.UploadSSHPublicKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UploadSSHPublicKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UploadSSHPublicKeyOutput) + return ret0, ret1 +} + +// UploadSSHPublicKeyRequest indicates an expected call of UploadSSHPublicKeyRequest +func (mr *MockIAMAPIMockRecorder) UploadSSHPublicKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadSSHPublicKeyRequest", reflect.TypeOf((*MockIAMAPI)(nil).UploadSSHPublicKeyRequest), arg0) +} + +// UploadSSHPublicKeyWithContext mocks base method +func (m *MockIAMAPI) UploadSSHPublicKeyWithContext(arg0 context.Context, arg1 *iam.UploadSSHPublicKeyInput, arg2 ...request.Option) (*iam.UploadSSHPublicKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UploadSSHPublicKeyWithContext", varargs...) + ret0, _ := ret[0].(*iam.UploadSSHPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadSSHPublicKeyWithContext indicates an expected call of UploadSSHPublicKeyWithContext +func (mr *MockIAMAPIMockRecorder) UploadSSHPublicKeyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadSSHPublicKeyWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UploadSSHPublicKeyWithContext), varargs...) +} + +// UploadServerCertificate mocks base method +func (m *MockIAMAPI) UploadServerCertificate(arg0 *iam.UploadServerCertificateInput) (*iam.UploadServerCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UploadServerCertificate", arg0) + ret0, _ := ret[0].(*iam.UploadServerCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadServerCertificate indicates an expected call of UploadServerCertificate +func (mr *MockIAMAPIMockRecorder) UploadServerCertificate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadServerCertificate", reflect.TypeOf((*MockIAMAPI)(nil).UploadServerCertificate), arg0) +} + +// UploadServerCertificateRequest mocks base method +func (m *MockIAMAPI) UploadServerCertificateRequest(arg0 *iam.UploadServerCertificateInput) (*request.Request, *iam.UploadServerCertificateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UploadServerCertificateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UploadServerCertificateOutput) + return ret0, ret1 +} + +// UploadServerCertificateRequest indicates an expected call of UploadServerCertificateRequest +func (mr *MockIAMAPIMockRecorder) UploadServerCertificateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadServerCertificateRequest", reflect.TypeOf((*MockIAMAPI)(nil).UploadServerCertificateRequest), arg0) +} + +// UploadServerCertificateWithContext mocks base method +func (m *MockIAMAPI) UploadServerCertificateWithContext(arg0 context.Context, arg1 *iam.UploadServerCertificateInput, arg2 ...request.Option) (*iam.UploadServerCertificateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UploadServerCertificateWithContext", varargs...) + ret0, _ := ret[0].(*iam.UploadServerCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadServerCertificateWithContext indicates an expected call of UploadServerCertificateWithContext +func (mr *MockIAMAPIMockRecorder) UploadServerCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadServerCertificateWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UploadServerCertificateWithContext), varargs...) +} + +// UploadSigningCertificate mocks base method +func (m *MockIAMAPI) UploadSigningCertificate(arg0 *iam.UploadSigningCertificateInput) (*iam.UploadSigningCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UploadSigningCertificate", arg0) + ret0, _ := ret[0].(*iam.UploadSigningCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadSigningCertificate indicates an expected call of UploadSigningCertificate +func (mr *MockIAMAPIMockRecorder) UploadSigningCertificate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadSigningCertificate", reflect.TypeOf((*MockIAMAPI)(nil).UploadSigningCertificate), arg0) +} + +// UploadSigningCertificateRequest mocks base method +func (m *MockIAMAPI) UploadSigningCertificateRequest(arg0 *iam.UploadSigningCertificateInput) (*request.Request, *iam.UploadSigningCertificateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UploadSigningCertificateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*iam.UploadSigningCertificateOutput) + return ret0, ret1 +} + +// UploadSigningCertificateRequest indicates an expected call of UploadSigningCertificateRequest +func (mr *MockIAMAPIMockRecorder) UploadSigningCertificateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadSigningCertificateRequest", reflect.TypeOf((*MockIAMAPI)(nil).UploadSigningCertificateRequest), arg0) +} + +// UploadSigningCertificateWithContext mocks base method +func (m *MockIAMAPI) UploadSigningCertificateWithContext(arg0 context.Context, arg1 *iam.UploadSigningCertificateInput, arg2 ...request.Option) (*iam.UploadSigningCertificateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UploadSigningCertificateWithContext", varargs...) + ret0, _ := ret[0].(*iam.UploadSigningCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadSigningCertificateWithContext indicates an expected call of UploadSigningCertificateWithContext +func (mr *MockIAMAPIMockRecorder) UploadSigningCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadSigningCertificateWithContext", reflect.TypeOf((*MockIAMAPI)(nil).UploadSigningCertificateWithContext), varargs...) +} + +// WaitUntilInstanceProfileExists mocks base method +func (m *MockIAMAPI) WaitUntilInstanceProfileExists(arg0 *iam.GetInstanceProfileInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilInstanceProfileExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceProfileExists indicates an expected call of WaitUntilInstanceProfileExists +func (mr *MockIAMAPIMockRecorder) WaitUntilInstanceProfileExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceProfileExists", reflect.TypeOf((*MockIAMAPI)(nil).WaitUntilInstanceProfileExists), arg0) +} + +// WaitUntilInstanceProfileExistsWithContext mocks base method +func (m *MockIAMAPI) WaitUntilInstanceProfileExistsWithContext(arg0 context.Context, arg1 *iam.GetInstanceProfileInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilInstanceProfileExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilInstanceProfileExistsWithContext indicates an expected call of WaitUntilInstanceProfileExistsWithContext +func (mr *MockIAMAPIMockRecorder) WaitUntilInstanceProfileExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceProfileExistsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).WaitUntilInstanceProfileExistsWithContext), varargs...) +} + +// WaitUntilPolicyExists mocks base method +func (m *MockIAMAPI) WaitUntilPolicyExists(arg0 *iam.GetPolicyInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilPolicyExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilPolicyExists indicates an expected call of WaitUntilPolicyExists +func (mr *MockIAMAPIMockRecorder) WaitUntilPolicyExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPolicyExists", reflect.TypeOf((*MockIAMAPI)(nil).WaitUntilPolicyExists), arg0) +} + +// WaitUntilPolicyExistsWithContext mocks base method +func (m *MockIAMAPI) WaitUntilPolicyExistsWithContext(arg0 context.Context, arg1 *iam.GetPolicyInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilPolicyExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilPolicyExistsWithContext indicates an expected call of WaitUntilPolicyExistsWithContext +func (mr *MockIAMAPIMockRecorder) WaitUntilPolicyExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPolicyExistsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).WaitUntilPolicyExistsWithContext), varargs...) +} + +// WaitUntilRoleExists mocks base method +func (m *MockIAMAPI) WaitUntilRoleExists(arg0 *iam.GetRoleInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilRoleExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilRoleExists indicates an expected call of WaitUntilRoleExists +func (mr *MockIAMAPIMockRecorder) WaitUntilRoleExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilRoleExists", reflect.TypeOf((*MockIAMAPI)(nil).WaitUntilRoleExists), arg0) +} + +// WaitUntilRoleExistsWithContext mocks base method +func (m *MockIAMAPI) WaitUntilRoleExistsWithContext(arg0 context.Context, arg1 *iam.GetRoleInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilRoleExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilRoleExistsWithContext indicates an expected call of WaitUntilRoleExistsWithContext +func (mr *MockIAMAPIMockRecorder) WaitUntilRoleExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilRoleExistsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).WaitUntilRoleExistsWithContext), varargs...) +} + +// WaitUntilUserExists mocks base method +func (m *MockIAMAPI) WaitUntilUserExists(arg0 *iam.GetUserInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilUserExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilUserExists indicates an expected call of WaitUntilUserExists +func (mr *MockIAMAPIMockRecorder) WaitUntilUserExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilUserExists", reflect.TypeOf((*MockIAMAPI)(nil).WaitUntilUserExists), arg0) +} + +// WaitUntilUserExistsWithContext mocks base method +func (m *MockIAMAPI) WaitUntilUserExistsWithContext(arg0 context.Context, arg1 *iam.GetUserInput, arg2 ...request.WaiterOption) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilUserExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilUserExistsWithContext indicates an expected call of WaitUntilUserExistsWithContext +func (mr *MockIAMAPIMockRecorder) WaitUntilUserExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilUserExistsWithContext", reflect.TypeOf((*MockIAMAPI)(nil).WaitUntilUserExistsWithContext), varargs...) +} diff --git a/pkg/mocks/mock_inspector.go b/pkg/mocks/mock_inspector.go new file mode 100644 index 0000000..287459c --- /dev/null +++ b/pkg/mocks/mock_inspector.go @@ -0,0 +1,2216 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/inspector/inspectoriface (interfaces: InspectorAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + inspector "github.com/aws/aws-sdk-go/service/inspector" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockInspectorAPI is a mock of InspectorAPI interface +type MockInspectorAPI struct { + ctrl *gomock.Controller + recorder *MockInspectorAPIMockRecorder +} + +// MockInspectorAPIMockRecorder is the mock recorder for MockInspectorAPI +type MockInspectorAPIMockRecorder struct { + mock *MockInspectorAPI +} + +// NewMockInspectorAPI creates a new mock instance +func NewMockInspectorAPI(ctrl *gomock.Controller) *MockInspectorAPI { + mock := &MockInspectorAPI{ctrl: ctrl} + mock.recorder = &MockInspectorAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockInspectorAPI) EXPECT() *MockInspectorAPIMockRecorder { + return m.recorder +} + +// AddAttributesToFindings mocks base method +func (m *MockInspectorAPI) AddAttributesToFindings(arg0 *inspector.AddAttributesToFindingsInput) (*inspector.AddAttributesToFindingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddAttributesToFindings", arg0) + ret0, _ := ret[0].(*inspector.AddAttributesToFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddAttributesToFindings indicates an expected call of AddAttributesToFindings +func (mr *MockInspectorAPIMockRecorder) AddAttributesToFindings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAttributesToFindings", reflect.TypeOf((*MockInspectorAPI)(nil).AddAttributesToFindings), arg0) +} + +// AddAttributesToFindingsRequest mocks base method +func (m *MockInspectorAPI) AddAttributesToFindingsRequest(arg0 *inspector.AddAttributesToFindingsInput) (*request.Request, *inspector.AddAttributesToFindingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddAttributesToFindingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.AddAttributesToFindingsOutput) + return ret0, ret1 +} + +// AddAttributesToFindingsRequest indicates an expected call of AddAttributesToFindingsRequest +func (mr *MockInspectorAPIMockRecorder) AddAttributesToFindingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAttributesToFindingsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).AddAttributesToFindingsRequest), arg0) +} + +// AddAttributesToFindingsWithContext mocks base method +func (m *MockInspectorAPI) AddAttributesToFindingsWithContext(arg0 context.Context, arg1 *inspector.AddAttributesToFindingsInput, arg2 ...request.Option) (*inspector.AddAttributesToFindingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddAttributesToFindingsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.AddAttributesToFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddAttributesToFindingsWithContext indicates an expected call of AddAttributesToFindingsWithContext +func (mr *MockInspectorAPIMockRecorder) AddAttributesToFindingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAttributesToFindingsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).AddAttributesToFindingsWithContext), varargs...) +} + +// CreateAssessmentTarget mocks base method +func (m *MockInspectorAPI) CreateAssessmentTarget(arg0 *inspector.CreateAssessmentTargetInput) (*inspector.CreateAssessmentTargetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAssessmentTarget", arg0) + ret0, _ := ret[0].(*inspector.CreateAssessmentTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAssessmentTarget indicates an expected call of CreateAssessmentTarget +func (mr *MockInspectorAPIMockRecorder) CreateAssessmentTarget(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssessmentTarget", reflect.TypeOf((*MockInspectorAPI)(nil).CreateAssessmentTarget), arg0) +} + +// CreateAssessmentTargetRequest mocks base method +func (m *MockInspectorAPI) CreateAssessmentTargetRequest(arg0 *inspector.CreateAssessmentTargetInput) (*request.Request, *inspector.CreateAssessmentTargetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAssessmentTargetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.CreateAssessmentTargetOutput) + return ret0, ret1 +} + +// CreateAssessmentTargetRequest indicates an expected call of CreateAssessmentTargetRequest +func (mr *MockInspectorAPIMockRecorder) CreateAssessmentTargetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssessmentTargetRequest", reflect.TypeOf((*MockInspectorAPI)(nil).CreateAssessmentTargetRequest), arg0) +} + +// CreateAssessmentTargetWithContext mocks base method +func (m *MockInspectorAPI) CreateAssessmentTargetWithContext(arg0 context.Context, arg1 *inspector.CreateAssessmentTargetInput, arg2 ...request.Option) (*inspector.CreateAssessmentTargetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateAssessmentTargetWithContext", varargs...) + ret0, _ := ret[0].(*inspector.CreateAssessmentTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAssessmentTargetWithContext indicates an expected call of CreateAssessmentTargetWithContext +func (mr *MockInspectorAPIMockRecorder) CreateAssessmentTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssessmentTargetWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).CreateAssessmentTargetWithContext), varargs...) +} + +// CreateAssessmentTemplate mocks base method +func (m *MockInspectorAPI) CreateAssessmentTemplate(arg0 *inspector.CreateAssessmentTemplateInput) (*inspector.CreateAssessmentTemplateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAssessmentTemplate", arg0) + ret0, _ := ret[0].(*inspector.CreateAssessmentTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAssessmentTemplate indicates an expected call of CreateAssessmentTemplate +func (mr *MockInspectorAPIMockRecorder) CreateAssessmentTemplate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssessmentTemplate", reflect.TypeOf((*MockInspectorAPI)(nil).CreateAssessmentTemplate), arg0) +} + +// CreateAssessmentTemplateRequest mocks base method +func (m *MockInspectorAPI) CreateAssessmentTemplateRequest(arg0 *inspector.CreateAssessmentTemplateInput) (*request.Request, *inspector.CreateAssessmentTemplateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAssessmentTemplateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.CreateAssessmentTemplateOutput) + return ret0, ret1 +} + +// CreateAssessmentTemplateRequest indicates an expected call of CreateAssessmentTemplateRequest +func (mr *MockInspectorAPIMockRecorder) CreateAssessmentTemplateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssessmentTemplateRequest", reflect.TypeOf((*MockInspectorAPI)(nil).CreateAssessmentTemplateRequest), arg0) +} + +// CreateAssessmentTemplateWithContext mocks base method +func (m *MockInspectorAPI) CreateAssessmentTemplateWithContext(arg0 context.Context, arg1 *inspector.CreateAssessmentTemplateInput, arg2 ...request.Option) (*inspector.CreateAssessmentTemplateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateAssessmentTemplateWithContext", varargs...) + ret0, _ := ret[0].(*inspector.CreateAssessmentTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAssessmentTemplateWithContext indicates an expected call of CreateAssessmentTemplateWithContext +func (mr *MockInspectorAPIMockRecorder) CreateAssessmentTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAssessmentTemplateWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).CreateAssessmentTemplateWithContext), varargs...) +} + +// CreateExclusionsPreview mocks base method +func (m *MockInspectorAPI) CreateExclusionsPreview(arg0 *inspector.CreateExclusionsPreviewInput) (*inspector.CreateExclusionsPreviewOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateExclusionsPreview", arg0) + ret0, _ := ret[0].(*inspector.CreateExclusionsPreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateExclusionsPreview indicates an expected call of CreateExclusionsPreview +func (mr *MockInspectorAPIMockRecorder) CreateExclusionsPreview(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExclusionsPreview", reflect.TypeOf((*MockInspectorAPI)(nil).CreateExclusionsPreview), arg0) +} + +// CreateExclusionsPreviewRequest mocks base method +func (m *MockInspectorAPI) CreateExclusionsPreviewRequest(arg0 *inspector.CreateExclusionsPreviewInput) (*request.Request, *inspector.CreateExclusionsPreviewOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateExclusionsPreviewRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.CreateExclusionsPreviewOutput) + return ret0, ret1 +} + +// CreateExclusionsPreviewRequest indicates an expected call of CreateExclusionsPreviewRequest +func (mr *MockInspectorAPIMockRecorder) CreateExclusionsPreviewRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExclusionsPreviewRequest", reflect.TypeOf((*MockInspectorAPI)(nil).CreateExclusionsPreviewRequest), arg0) +} + +// CreateExclusionsPreviewWithContext mocks base method +func (m *MockInspectorAPI) CreateExclusionsPreviewWithContext(arg0 context.Context, arg1 *inspector.CreateExclusionsPreviewInput, arg2 ...request.Option) (*inspector.CreateExclusionsPreviewOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateExclusionsPreviewWithContext", varargs...) + ret0, _ := ret[0].(*inspector.CreateExclusionsPreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateExclusionsPreviewWithContext indicates an expected call of CreateExclusionsPreviewWithContext +func (mr *MockInspectorAPIMockRecorder) CreateExclusionsPreviewWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExclusionsPreviewWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).CreateExclusionsPreviewWithContext), varargs...) +} + +// CreateResourceGroup mocks base method +func (m *MockInspectorAPI) CreateResourceGroup(arg0 *inspector.CreateResourceGroupInput) (*inspector.CreateResourceGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateResourceGroup", arg0) + ret0, _ := ret[0].(*inspector.CreateResourceGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateResourceGroup indicates an expected call of CreateResourceGroup +func (mr *MockInspectorAPIMockRecorder) CreateResourceGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceGroup", reflect.TypeOf((*MockInspectorAPI)(nil).CreateResourceGroup), arg0) +} + +// CreateResourceGroupRequest mocks base method +func (m *MockInspectorAPI) CreateResourceGroupRequest(arg0 *inspector.CreateResourceGroupInput) (*request.Request, *inspector.CreateResourceGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateResourceGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.CreateResourceGroupOutput) + return ret0, ret1 +} + +// CreateResourceGroupRequest indicates an expected call of CreateResourceGroupRequest +func (mr *MockInspectorAPIMockRecorder) CreateResourceGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceGroupRequest", reflect.TypeOf((*MockInspectorAPI)(nil).CreateResourceGroupRequest), arg0) +} + +// CreateResourceGroupWithContext mocks base method +func (m *MockInspectorAPI) CreateResourceGroupWithContext(arg0 context.Context, arg1 *inspector.CreateResourceGroupInput, arg2 ...request.Option) (*inspector.CreateResourceGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateResourceGroupWithContext", varargs...) + ret0, _ := ret[0].(*inspector.CreateResourceGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateResourceGroupWithContext indicates an expected call of CreateResourceGroupWithContext +func (mr *MockInspectorAPIMockRecorder) CreateResourceGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceGroupWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).CreateResourceGroupWithContext), varargs...) +} + +// DeleteAssessmentRun mocks base method +func (m *MockInspectorAPI) DeleteAssessmentRun(arg0 *inspector.DeleteAssessmentRunInput) (*inspector.DeleteAssessmentRunOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAssessmentRun", arg0) + ret0, _ := ret[0].(*inspector.DeleteAssessmentRunOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAssessmentRun indicates an expected call of DeleteAssessmentRun +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentRun(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentRun", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentRun), arg0) +} + +// DeleteAssessmentRunRequest mocks base method +func (m *MockInspectorAPI) DeleteAssessmentRunRequest(arg0 *inspector.DeleteAssessmentRunInput) (*request.Request, *inspector.DeleteAssessmentRunOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAssessmentRunRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DeleteAssessmentRunOutput) + return ret0, ret1 +} + +// DeleteAssessmentRunRequest indicates an expected call of DeleteAssessmentRunRequest +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentRunRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentRunRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentRunRequest), arg0) +} + +// DeleteAssessmentRunWithContext mocks base method +func (m *MockInspectorAPI) DeleteAssessmentRunWithContext(arg0 context.Context, arg1 *inspector.DeleteAssessmentRunInput, arg2 ...request.Option) (*inspector.DeleteAssessmentRunOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAssessmentRunWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DeleteAssessmentRunOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAssessmentRunWithContext indicates an expected call of DeleteAssessmentRunWithContext +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentRunWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentRunWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentRunWithContext), varargs...) +} + +// DeleteAssessmentTarget mocks base method +func (m *MockInspectorAPI) DeleteAssessmentTarget(arg0 *inspector.DeleteAssessmentTargetInput) (*inspector.DeleteAssessmentTargetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAssessmentTarget", arg0) + ret0, _ := ret[0].(*inspector.DeleteAssessmentTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAssessmentTarget indicates an expected call of DeleteAssessmentTarget +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentTarget(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentTarget", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentTarget), arg0) +} + +// DeleteAssessmentTargetRequest mocks base method +func (m *MockInspectorAPI) DeleteAssessmentTargetRequest(arg0 *inspector.DeleteAssessmentTargetInput) (*request.Request, *inspector.DeleteAssessmentTargetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAssessmentTargetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DeleteAssessmentTargetOutput) + return ret0, ret1 +} + +// DeleteAssessmentTargetRequest indicates an expected call of DeleteAssessmentTargetRequest +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentTargetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentTargetRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentTargetRequest), arg0) +} + +// DeleteAssessmentTargetWithContext mocks base method +func (m *MockInspectorAPI) DeleteAssessmentTargetWithContext(arg0 context.Context, arg1 *inspector.DeleteAssessmentTargetInput, arg2 ...request.Option) (*inspector.DeleteAssessmentTargetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAssessmentTargetWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DeleteAssessmentTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAssessmentTargetWithContext indicates an expected call of DeleteAssessmentTargetWithContext +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentTargetWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentTargetWithContext), varargs...) +} + +// DeleteAssessmentTemplate mocks base method +func (m *MockInspectorAPI) DeleteAssessmentTemplate(arg0 *inspector.DeleteAssessmentTemplateInput) (*inspector.DeleteAssessmentTemplateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAssessmentTemplate", arg0) + ret0, _ := ret[0].(*inspector.DeleteAssessmentTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAssessmentTemplate indicates an expected call of DeleteAssessmentTemplate +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentTemplate(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentTemplate", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentTemplate), arg0) +} + +// DeleteAssessmentTemplateRequest mocks base method +func (m *MockInspectorAPI) DeleteAssessmentTemplateRequest(arg0 *inspector.DeleteAssessmentTemplateInput) (*request.Request, *inspector.DeleteAssessmentTemplateOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAssessmentTemplateRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DeleteAssessmentTemplateOutput) + return ret0, ret1 +} + +// DeleteAssessmentTemplateRequest indicates an expected call of DeleteAssessmentTemplateRequest +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentTemplateRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentTemplateRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentTemplateRequest), arg0) +} + +// DeleteAssessmentTemplateWithContext mocks base method +func (m *MockInspectorAPI) DeleteAssessmentTemplateWithContext(arg0 context.Context, arg1 *inspector.DeleteAssessmentTemplateInput, arg2 ...request.Option) (*inspector.DeleteAssessmentTemplateOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAssessmentTemplateWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DeleteAssessmentTemplateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAssessmentTemplateWithContext indicates an expected call of DeleteAssessmentTemplateWithContext +func (mr *MockInspectorAPIMockRecorder) DeleteAssessmentTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAssessmentTemplateWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DeleteAssessmentTemplateWithContext), varargs...) +} + +// DescribeAssessmentRuns mocks base method +func (m *MockInspectorAPI) DescribeAssessmentRuns(arg0 *inspector.DescribeAssessmentRunsInput) (*inspector.DescribeAssessmentRunsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAssessmentRuns", arg0) + ret0, _ := ret[0].(*inspector.DescribeAssessmentRunsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAssessmentRuns indicates an expected call of DescribeAssessmentRuns +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentRuns(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentRuns", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentRuns), arg0) +} + +// DescribeAssessmentRunsRequest mocks base method +func (m *MockInspectorAPI) DescribeAssessmentRunsRequest(arg0 *inspector.DescribeAssessmentRunsInput) (*request.Request, *inspector.DescribeAssessmentRunsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAssessmentRunsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DescribeAssessmentRunsOutput) + return ret0, ret1 +} + +// DescribeAssessmentRunsRequest indicates an expected call of DescribeAssessmentRunsRequest +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentRunsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentRunsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentRunsRequest), arg0) +} + +// DescribeAssessmentRunsWithContext mocks base method +func (m *MockInspectorAPI) DescribeAssessmentRunsWithContext(arg0 context.Context, arg1 *inspector.DescribeAssessmentRunsInput, arg2 ...request.Option) (*inspector.DescribeAssessmentRunsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAssessmentRunsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DescribeAssessmentRunsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAssessmentRunsWithContext indicates an expected call of DescribeAssessmentRunsWithContext +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentRunsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentRunsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentRunsWithContext), varargs...) +} + +// DescribeAssessmentTargets mocks base method +func (m *MockInspectorAPI) DescribeAssessmentTargets(arg0 *inspector.DescribeAssessmentTargetsInput) (*inspector.DescribeAssessmentTargetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAssessmentTargets", arg0) + ret0, _ := ret[0].(*inspector.DescribeAssessmentTargetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAssessmentTargets indicates an expected call of DescribeAssessmentTargets +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentTargets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentTargets", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentTargets), arg0) +} + +// DescribeAssessmentTargetsRequest mocks base method +func (m *MockInspectorAPI) DescribeAssessmentTargetsRequest(arg0 *inspector.DescribeAssessmentTargetsInput) (*request.Request, *inspector.DescribeAssessmentTargetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAssessmentTargetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DescribeAssessmentTargetsOutput) + return ret0, ret1 +} + +// DescribeAssessmentTargetsRequest indicates an expected call of DescribeAssessmentTargetsRequest +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentTargetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentTargetsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentTargetsRequest), arg0) +} + +// DescribeAssessmentTargetsWithContext mocks base method +func (m *MockInspectorAPI) DescribeAssessmentTargetsWithContext(arg0 context.Context, arg1 *inspector.DescribeAssessmentTargetsInput, arg2 ...request.Option) (*inspector.DescribeAssessmentTargetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAssessmentTargetsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DescribeAssessmentTargetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAssessmentTargetsWithContext indicates an expected call of DescribeAssessmentTargetsWithContext +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentTargetsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentTargetsWithContext), varargs...) +} + +// DescribeAssessmentTemplates mocks base method +func (m *MockInspectorAPI) DescribeAssessmentTemplates(arg0 *inspector.DescribeAssessmentTemplatesInput) (*inspector.DescribeAssessmentTemplatesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAssessmentTemplates", arg0) + ret0, _ := ret[0].(*inspector.DescribeAssessmentTemplatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAssessmentTemplates indicates an expected call of DescribeAssessmentTemplates +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentTemplates(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentTemplates", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentTemplates), arg0) +} + +// DescribeAssessmentTemplatesRequest mocks base method +func (m *MockInspectorAPI) DescribeAssessmentTemplatesRequest(arg0 *inspector.DescribeAssessmentTemplatesInput) (*request.Request, *inspector.DescribeAssessmentTemplatesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAssessmentTemplatesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DescribeAssessmentTemplatesOutput) + return ret0, ret1 +} + +// DescribeAssessmentTemplatesRequest indicates an expected call of DescribeAssessmentTemplatesRequest +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentTemplatesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentTemplatesRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentTemplatesRequest), arg0) +} + +// DescribeAssessmentTemplatesWithContext mocks base method +func (m *MockInspectorAPI) DescribeAssessmentTemplatesWithContext(arg0 context.Context, arg1 *inspector.DescribeAssessmentTemplatesInput, arg2 ...request.Option) (*inspector.DescribeAssessmentTemplatesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAssessmentTemplatesWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DescribeAssessmentTemplatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAssessmentTemplatesWithContext indicates an expected call of DescribeAssessmentTemplatesWithContext +func (mr *MockInspectorAPIMockRecorder) DescribeAssessmentTemplatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAssessmentTemplatesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeAssessmentTemplatesWithContext), varargs...) +} + +// DescribeCrossAccountAccessRole mocks base method +func (m *MockInspectorAPI) DescribeCrossAccountAccessRole(arg0 *inspector.DescribeCrossAccountAccessRoleInput) (*inspector.DescribeCrossAccountAccessRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCrossAccountAccessRole", arg0) + ret0, _ := ret[0].(*inspector.DescribeCrossAccountAccessRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCrossAccountAccessRole indicates an expected call of DescribeCrossAccountAccessRole +func (mr *MockInspectorAPIMockRecorder) DescribeCrossAccountAccessRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCrossAccountAccessRole", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeCrossAccountAccessRole), arg0) +} + +// DescribeCrossAccountAccessRoleRequest mocks base method +func (m *MockInspectorAPI) DescribeCrossAccountAccessRoleRequest(arg0 *inspector.DescribeCrossAccountAccessRoleInput) (*request.Request, *inspector.DescribeCrossAccountAccessRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCrossAccountAccessRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DescribeCrossAccountAccessRoleOutput) + return ret0, ret1 +} + +// DescribeCrossAccountAccessRoleRequest indicates an expected call of DescribeCrossAccountAccessRoleRequest +func (mr *MockInspectorAPIMockRecorder) DescribeCrossAccountAccessRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCrossAccountAccessRoleRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeCrossAccountAccessRoleRequest), arg0) +} + +// DescribeCrossAccountAccessRoleWithContext mocks base method +func (m *MockInspectorAPI) DescribeCrossAccountAccessRoleWithContext(arg0 context.Context, arg1 *inspector.DescribeCrossAccountAccessRoleInput, arg2 ...request.Option) (*inspector.DescribeCrossAccountAccessRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCrossAccountAccessRoleWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DescribeCrossAccountAccessRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCrossAccountAccessRoleWithContext indicates an expected call of DescribeCrossAccountAccessRoleWithContext +func (mr *MockInspectorAPIMockRecorder) DescribeCrossAccountAccessRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCrossAccountAccessRoleWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeCrossAccountAccessRoleWithContext), varargs...) +} + +// DescribeExclusions mocks base method +func (m *MockInspectorAPI) DescribeExclusions(arg0 *inspector.DescribeExclusionsInput) (*inspector.DescribeExclusionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExclusions", arg0) + ret0, _ := ret[0].(*inspector.DescribeExclusionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeExclusions indicates an expected call of DescribeExclusions +func (mr *MockInspectorAPIMockRecorder) DescribeExclusions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExclusions", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeExclusions), arg0) +} + +// DescribeExclusionsRequest mocks base method +func (m *MockInspectorAPI) DescribeExclusionsRequest(arg0 *inspector.DescribeExclusionsInput) (*request.Request, *inspector.DescribeExclusionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeExclusionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DescribeExclusionsOutput) + return ret0, ret1 +} + +// DescribeExclusionsRequest indicates an expected call of DescribeExclusionsRequest +func (mr *MockInspectorAPIMockRecorder) DescribeExclusionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExclusionsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeExclusionsRequest), arg0) +} + +// DescribeExclusionsWithContext mocks base method +func (m *MockInspectorAPI) DescribeExclusionsWithContext(arg0 context.Context, arg1 *inspector.DescribeExclusionsInput, arg2 ...request.Option) (*inspector.DescribeExclusionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeExclusionsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DescribeExclusionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeExclusionsWithContext indicates an expected call of DescribeExclusionsWithContext +func (mr *MockInspectorAPIMockRecorder) DescribeExclusionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExclusionsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeExclusionsWithContext), varargs...) +} + +// DescribeFindings mocks base method +func (m *MockInspectorAPI) DescribeFindings(arg0 *inspector.DescribeFindingsInput) (*inspector.DescribeFindingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFindings", arg0) + ret0, _ := ret[0].(*inspector.DescribeFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFindings indicates an expected call of DescribeFindings +func (mr *MockInspectorAPIMockRecorder) DescribeFindings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFindings", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeFindings), arg0) +} + +// DescribeFindingsRequest mocks base method +func (m *MockInspectorAPI) DescribeFindingsRequest(arg0 *inspector.DescribeFindingsInput) (*request.Request, *inspector.DescribeFindingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeFindingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DescribeFindingsOutput) + return ret0, ret1 +} + +// DescribeFindingsRequest indicates an expected call of DescribeFindingsRequest +func (mr *MockInspectorAPIMockRecorder) DescribeFindingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFindingsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeFindingsRequest), arg0) +} + +// DescribeFindingsWithContext mocks base method +func (m *MockInspectorAPI) DescribeFindingsWithContext(arg0 context.Context, arg1 *inspector.DescribeFindingsInput, arg2 ...request.Option) (*inspector.DescribeFindingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeFindingsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DescribeFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeFindingsWithContext indicates an expected call of DescribeFindingsWithContext +func (mr *MockInspectorAPIMockRecorder) DescribeFindingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFindingsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeFindingsWithContext), varargs...) +} + +// DescribeResourceGroups mocks base method +func (m *MockInspectorAPI) DescribeResourceGroups(arg0 *inspector.DescribeResourceGroupsInput) (*inspector.DescribeResourceGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeResourceGroups", arg0) + ret0, _ := ret[0].(*inspector.DescribeResourceGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeResourceGroups indicates an expected call of DescribeResourceGroups +func (mr *MockInspectorAPIMockRecorder) DescribeResourceGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeResourceGroups", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeResourceGroups), arg0) +} + +// DescribeResourceGroupsRequest mocks base method +func (m *MockInspectorAPI) DescribeResourceGroupsRequest(arg0 *inspector.DescribeResourceGroupsInput) (*request.Request, *inspector.DescribeResourceGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeResourceGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DescribeResourceGroupsOutput) + return ret0, ret1 +} + +// DescribeResourceGroupsRequest indicates an expected call of DescribeResourceGroupsRequest +func (mr *MockInspectorAPIMockRecorder) DescribeResourceGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeResourceGroupsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeResourceGroupsRequest), arg0) +} + +// DescribeResourceGroupsWithContext mocks base method +func (m *MockInspectorAPI) DescribeResourceGroupsWithContext(arg0 context.Context, arg1 *inspector.DescribeResourceGroupsInput, arg2 ...request.Option) (*inspector.DescribeResourceGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeResourceGroupsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DescribeResourceGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeResourceGroupsWithContext indicates an expected call of DescribeResourceGroupsWithContext +func (mr *MockInspectorAPIMockRecorder) DescribeResourceGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeResourceGroupsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeResourceGroupsWithContext), varargs...) +} + +// DescribeRulesPackages mocks base method +func (m *MockInspectorAPI) DescribeRulesPackages(arg0 *inspector.DescribeRulesPackagesInput) (*inspector.DescribeRulesPackagesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRulesPackages", arg0) + ret0, _ := ret[0].(*inspector.DescribeRulesPackagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRulesPackages indicates an expected call of DescribeRulesPackages +func (mr *MockInspectorAPIMockRecorder) DescribeRulesPackages(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesPackages", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeRulesPackages), arg0) +} + +// DescribeRulesPackagesRequest mocks base method +func (m *MockInspectorAPI) DescribeRulesPackagesRequest(arg0 *inspector.DescribeRulesPackagesInput) (*request.Request, *inspector.DescribeRulesPackagesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeRulesPackagesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.DescribeRulesPackagesOutput) + return ret0, ret1 +} + +// DescribeRulesPackagesRequest indicates an expected call of DescribeRulesPackagesRequest +func (mr *MockInspectorAPIMockRecorder) DescribeRulesPackagesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesPackagesRequest", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeRulesPackagesRequest), arg0) +} + +// DescribeRulesPackagesWithContext mocks base method +func (m *MockInspectorAPI) DescribeRulesPackagesWithContext(arg0 context.Context, arg1 *inspector.DescribeRulesPackagesInput, arg2 ...request.Option) (*inspector.DescribeRulesPackagesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeRulesPackagesWithContext", varargs...) + ret0, _ := ret[0].(*inspector.DescribeRulesPackagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeRulesPackagesWithContext indicates an expected call of DescribeRulesPackagesWithContext +func (mr *MockInspectorAPIMockRecorder) DescribeRulesPackagesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesPackagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).DescribeRulesPackagesWithContext), varargs...) +} + +// GetAssessmentReport mocks base method +func (m *MockInspectorAPI) GetAssessmentReport(arg0 *inspector.GetAssessmentReportInput) (*inspector.GetAssessmentReportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAssessmentReport", arg0) + ret0, _ := ret[0].(*inspector.GetAssessmentReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAssessmentReport indicates an expected call of GetAssessmentReport +func (mr *MockInspectorAPIMockRecorder) GetAssessmentReport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssessmentReport", reflect.TypeOf((*MockInspectorAPI)(nil).GetAssessmentReport), arg0) +} + +// GetAssessmentReportRequest mocks base method +func (m *MockInspectorAPI) GetAssessmentReportRequest(arg0 *inspector.GetAssessmentReportInput) (*request.Request, *inspector.GetAssessmentReportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAssessmentReportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.GetAssessmentReportOutput) + return ret0, ret1 +} + +// GetAssessmentReportRequest indicates an expected call of GetAssessmentReportRequest +func (mr *MockInspectorAPIMockRecorder) GetAssessmentReportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssessmentReportRequest", reflect.TypeOf((*MockInspectorAPI)(nil).GetAssessmentReportRequest), arg0) +} + +// GetAssessmentReportWithContext mocks base method +func (m *MockInspectorAPI) GetAssessmentReportWithContext(arg0 context.Context, arg1 *inspector.GetAssessmentReportInput, arg2 ...request.Option) (*inspector.GetAssessmentReportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAssessmentReportWithContext", varargs...) + ret0, _ := ret[0].(*inspector.GetAssessmentReportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAssessmentReportWithContext indicates an expected call of GetAssessmentReportWithContext +func (mr *MockInspectorAPIMockRecorder) GetAssessmentReportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssessmentReportWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).GetAssessmentReportWithContext), varargs...) +} + +// GetExclusionsPreview mocks base method +func (m *MockInspectorAPI) GetExclusionsPreview(arg0 *inspector.GetExclusionsPreviewInput) (*inspector.GetExclusionsPreviewOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetExclusionsPreview", arg0) + ret0, _ := ret[0].(*inspector.GetExclusionsPreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetExclusionsPreview indicates an expected call of GetExclusionsPreview +func (mr *MockInspectorAPIMockRecorder) GetExclusionsPreview(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExclusionsPreview", reflect.TypeOf((*MockInspectorAPI)(nil).GetExclusionsPreview), arg0) +} + +// GetExclusionsPreviewPages mocks base method +func (m *MockInspectorAPI) GetExclusionsPreviewPages(arg0 *inspector.GetExclusionsPreviewInput, arg1 func(*inspector.GetExclusionsPreviewOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetExclusionsPreviewPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetExclusionsPreviewPages indicates an expected call of GetExclusionsPreviewPages +func (mr *MockInspectorAPIMockRecorder) GetExclusionsPreviewPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExclusionsPreviewPages", reflect.TypeOf((*MockInspectorAPI)(nil).GetExclusionsPreviewPages), arg0, arg1) +} + +// GetExclusionsPreviewPagesWithContext mocks base method +func (m *MockInspectorAPI) GetExclusionsPreviewPagesWithContext(arg0 context.Context, arg1 *inspector.GetExclusionsPreviewInput, arg2 func(*inspector.GetExclusionsPreviewOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetExclusionsPreviewPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetExclusionsPreviewPagesWithContext indicates an expected call of GetExclusionsPreviewPagesWithContext +func (mr *MockInspectorAPIMockRecorder) GetExclusionsPreviewPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExclusionsPreviewPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).GetExclusionsPreviewPagesWithContext), varargs...) +} + +// GetExclusionsPreviewRequest mocks base method +func (m *MockInspectorAPI) GetExclusionsPreviewRequest(arg0 *inspector.GetExclusionsPreviewInput) (*request.Request, *inspector.GetExclusionsPreviewOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetExclusionsPreviewRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.GetExclusionsPreviewOutput) + return ret0, ret1 +} + +// GetExclusionsPreviewRequest indicates an expected call of GetExclusionsPreviewRequest +func (mr *MockInspectorAPIMockRecorder) GetExclusionsPreviewRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExclusionsPreviewRequest", reflect.TypeOf((*MockInspectorAPI)(nil).GetExclusionsPreviewRequest), arg0) +} + +// GetExclusionsPreviewWithContext mocks base method +func (m *MockInspectorAPI) GetExclusionsPreviewWithContext(arg0 context.Context, arg1 *inspector.GetExclusionsPreviewInput, arg2 ...request.Option) (*inspector.GetExclusionsPreviewOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetExclusionsPreviewWithContext", varargs...) + ret0, _ := ret[0].(*inspector.GetExclusionsPreviewOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetExclusionsPreviewWithContext indicates an expected call of GetExclusionsPreviewWithContext +func (mr *MockInspectorAPIMockRecorder) GetExclusionsPreviewWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExclusionsPreviewWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).GetExclusionsPreviewWithContext), varargs...) +} + +// GetTelemetryMetadata mocks base method +func (m *MockInspectorAPI) GetTelemetryMetadata(arg0 *inspector.GetTelemetryMetadataInput) (*inspector.GetTelemetryMetadataOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTelemetryMetadata", arg0) + ret0, _ := ret[0].(*inspector.GetTelemetryMetadataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTelemetryMetadata indicates an expected call of GetTelemetryMetadata +func (mr *MockInspectorAPIMockRecorder) GetTelemetryMetadata(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTelemetryMetadata", reflect.TypeOf((*MockInspectorAPI)(nil).GetTelemetryMetadata), arg0) +} + +// GetTelemetryMetadataRequest mocks base method +func (m *MockInspectorAPI) GetTelemetryMetadataRequest(arg0 *inspector.GetTelemetryMetadataInput) (*request.Request, *inspector.GetTelemetryMetadataOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTelemetryMetadataRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.GetTelemetryMetadataOutput) + return ret0, ret1 +} + +// GetTelemetryMetadataRequest indicates an expected call of GetTelemetryMetadataRequest +func (mr *MockInspectorAPIMockRecorder) GetTelemetryMetadataRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTelemetryMetadataRequest", reflect.TypeOf((*MockInspectorAPI)(nil).GetTelemetryMetadataRequest), arg0) +} + +// GetTelemetryMetadataWithContext mocks base method +func (m *MockInspectorAPI) GetTelemetryMetadataWithContext(arg0 context.Context, arg1 *inspector.GetTelemetryMetadataInput, arg2 ...request.Option) (*inspector.GetTelemetryMetadataOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetTelemetryMetadataWithContext", varargs...) + ret0, _ := ret[0].(*inspector.GetTelemetryMetadataOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTelemetryMetadataWithContext indicates an expected call of GetTelemetryMetadataWithContext +func (mr *MockInspectorAPIMockRecorder) GetTelemetryMetadataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTelemetryMetadataWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).GetTelemetryMetadataWithContext), varargs...) +} + +// ListAssessmentRunAgents mocks base method +func (m *MockInspectorAPI) ListAssessmentRunAgents(arg0 *inspector.ListAssessmentRunAgentsInput) (*inspector.ListAssessmentRunAgentsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentRunAgents", arg0) + ret0, _ := ret[0].(*inspector.ListAssessmentRunAgentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAssessmentRunAgents indicates an expected call of ListAssessmentRunAgents +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunAgents(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunAgents", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunAgents), arg0) +} + +// ListAssessmentRunAgentsPages mocks base method +func (m *MockInspectorAPI) ListAssessmentRunAgentsPages(arg0 *inspector.ListAssessmentRunAgentsInput, arg1 func(*inspector.ListAssessmentRunAgentsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentRunAgentsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAssessmentRunAgentsPages indicates an expected call of ListAssessmentRunAgentsPages +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunAgentsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunAgentsPages", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunAgentsPages), arg0, arg1) +} + +// ListAssessmentRunAgentsPagesWithContext mocks base method +func (m *MockInspectorAPI) ListAssessmentRunAgentsPagesWithContext(arg0 context.Context, arg1 *inspector.ListAssessmentRunAgentsInput, arg2 func(*inspector.ListAssessmentRunAgentsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAssessmentRunAgentsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAssessmentRunAgentsPagesWithContext indicates an expected call of ListAssessmentRunAgentsPagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunAgentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunAgentsPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunAgentsPagesWithContext), varargs...) +} + +// ListAssessmentRunAgentsRequest mocks base method +func (m *MockInspectorAPI) ListAssessmentRunAgentsRequest(arg0 *inspector.ListAssessmentRunAgentsInput) (*request.Request, *inspector.ListAssessmentRunAgentsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentRunAgentsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListAssessmentRunAgentsOutput) + return ret0, ret1 +} + +// ListAssessmentRunAgentsRequest indicates an expected call of ListAssessmentRunAgentsRequest +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunAgentsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunAgentsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunAgentsRequest), arg0) +} + +// ListAssessmentRunAgentsWithContext mocks base method +func (m *MockInspectorAPI) ListAssessmentRunAgentsWithContext(arg0 context.Context, arg1 *inspector.ListAssessmentRunAgentsInput, arg2 ...request.Option) (*inspector.ListAssessmentRunAgentsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAssessmentRunAgentsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListAssessmentRunAgentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAssessmentRunAgentsWithContext indicates an expected call of ListAssessmentRunAgentsWithContext +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunAgentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunAgentsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunAgentsWithContext), varargs...) +} + +// ListAssessmentRuns mocks base method +func (m *MockInspectorAPI) ListAssessmentRuns(arg0 *inspector.ListAssessmentRunsInput) (*inspector.ListAssessmentRunsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentRuns", arg0) + ret0, _ := ret[0].(*inspector.ListAssessmentRunsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAssessmentRuns indicates an expected call of ListAssessmentRuns +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRuns(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRuns", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRuns), arg0) +} + +// ListAssessmentRunsPages mocks base method +func (m *MockInspectorAPI) ListAssessmentRunsPages(arg0 *inspector.ListAssessmentRunsInput, arg1 func(*inspector.ListAssessmentRunsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentRunsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAssessmentRunsPages indicates an expected call of ListAssessmentRunsPages +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunsPages", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunsPages), arg0, arg1) +} + +// ListAssessmentRunsPagesWithContext mocks base method +func (m *MockInspectorAPI) ListAssessmentRunsPagesWithContext(arg0 context.Context, arg1 *inspector.ListAssessmentRunsInput, arg2 func(*inspector.ListAssessmentRunsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAssessmentRunsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAssessmentRunsPagesWithContext indicates an expected call of ListAssessmentRunsPagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunsPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunsPagesWithContext), varargs...) +} + +// ListAssessmentRunsRequest mocks base method +func (m *MockInspectorAPI) ListAssessmentRunsRequest(arg0 *inspector.ListAssessmentRunsInput) (*request.Request, *inspector.ListAssessmentRunsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentRunsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListAssessmentRunsOutput) + return ret0, ret1 +} + +// ListAssessmentRunsRequest indicates an expected call of ListAssessmentRunsRequest +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunsRequest), arg0) +} + +// ListAssessmentRunsWithContext mocks base method +func (m *MockInspectorAPI) ListAssessmentRunsWithContext(arg0 context.Context, arg1 *inspector.ListAssessmentRunsInput, arg2 ...request.Option) (*inspector.ListAssessmentRunsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAssessmentRunsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListAssessmentRunsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAssessmentRunsWithContext indicates an expected call of ListAssessmentRunsWithContext +func (mr *MockInspectorAPIMockRecorder) ListAssessmentRunsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentRunsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentRunsWithContext), varargs...) +} + +// ListAssessmentTargets mocks base method +func (m *MockInspectorAPI) ListAssessmentTargets(arg0 *inspector.ListAssessmentTargetsInput) (*inspector.ListAssessmentTargetsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentTargets", arg0) + ret0, _ := ret[0].(*inspector.ListAssessmentTargetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAssessmentTargets indicates an expected call of ListAssessmentTargets +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTargets(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTargets", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTargets), arg0) +} + +// ListAssessmentTargetsPages mocks base method +func (m *MockInspectorAPI) ListAssessmentTargetsPages(arg0 *inspector.ListAssessmentTargetsInput, arg1 func(*inspector.ListAssessmentTargetsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentTargetsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAssessmentTargetsPages indicates an expected call of ListAssessmentTargetsPages +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTargetsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTargetsPages", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTargetsPages), arg0, arg1) +} + +// ListAssessmentTargetsPagesWithContext mocks base method +func (m *MockInspectorAPI) ListAssessmentTargetsPagesWithContext(arg0 context.Context, arg1 *inspector.ListAssessmentTargetsInput, arg2 func(*inspector.ListAssessmentTargetsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAssessmentTargetsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAssessmentTargetsPagesWithContext indicates an expected call of ListAssessmentTargetsPagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTargetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTargetsPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTargetsPagesWithContext), varargs...) +} + +// ListAssessmentTargetsRequest mocks base method +func (m *MockInspectorAPI) ListAssessmentTargetsRequest(arg0 *inspector.ListAssessmentTargetsInput) (*request.Request, *inspector.ListAssessmentTargetsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentTargetsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListAssessmentTargetsOutput) + return ret0, ret1 +} + +// ListAssessmentTargetsRequest indicates an expected call of ListAssessmentTargetsRequest +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTargetsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTargetsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTargetsRequest), arg0) +} + +// ListAssessmentTargetsWithContext mocks base method +func (m *MockInspectorAPI) ListAssessmentTargetsWithContext(arg0 context.Context, arg1 *inspector.ListAssessmentTargetsInput, arg2 ...request.Option) (*inspector.ListAssessmentTargetsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAssessmentTargetsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListAssessmentTargetsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAssessmentTargetsWithContext indicates an expected call of ListAssessmentTargetsWithContext +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTargetsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTargetsWithContext), varargs...) +} + +// ListAssessmentTemplates mocks base method +func (m *MockInspectorAPI) ListAssessmentTemplates(arg0 *inspector.ListAssessmentTemplatesInput) (*inspector.ListAssessmentTemplatesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentTemplates", arg0) + ret0, _ := ret[0].(*inspector.ListAssessmentTemplatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAssessmentTemplates indicates an expected call of ListAssessmentTemplates +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTemplates(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTemplates", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTemplates), arg0) +} + +// ListAssessmentTemplatesPages mocks base method +func (m *MockInspectorAPI) ListAssessmentTemplatesPages(arg0 *inspector.ListAssessmentTemplatesInput, arg1 func(*inspector.ListAssessmentTemplatesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentTemplatesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAssessmentTemplatesPages indicates an expected call of ListAssessmentTemplatesPages +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTemplatesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTemplatesPages", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTemplatesPages), arg0, arg1) +} + +// ListAssessmentTemplatesPagesWithContext mocks base method +func (m *MockInspectorAPI) ListAssessmentTemplatesPagesWithContext(arg0 context.Context, arg1 *inspector.ListAssessmentTemplatesInput, arg2 func(*inspector.ListAssessmentTemplatesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAssessmentTemplatesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAssessmentTemplatesPagesWithContext indicates an expected call of ListAssessmentTemplatesPagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTemplatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTemplatesPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTemplatesPagesWithContext), varargs...) +} + +// ListAssessmentTemplatesRequest mocks base method +func (m *MockInspectorAPI) ListAssessmentTemplatesRequest(arg0 *inspector.ListAssessmentTemplatesInput) (*request.Request, *inspector.ListAssessmentTemplatesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAssessmentTemplatesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListAssessmentTemplatesOutput) + return ret0, ret1 +} + +// ListAssessmentTemplatesRequest indicates an expected call of ListAssessmentTemplatesRequest +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTemplatesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTemplatesRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTemplatesRequest), arg0) +} + +// ListAssessmentTemplatesWithContext mocks base method +func (m *MockInspectorAPI) ListAssessmentTemplatesWithContext(arg0 context.Context, arg1 *inspector.ListAssessmentTemplatesInput, arg2 ...request.Option) (*inspector.ListAssessmentTemplatesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAssessmentTemplatesWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListAssessmentTemplatesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAssessmentTemplatesWithContext indicates an expected call of ListAssessmentTemplatesWithContext +func (mr *MockInspectorAPIMockRecorder) ListAssessmentTemplatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAssessmentTemplatesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListAssessmentTemplatesWithContext), varargs...) +} + +// ListEventSubscriptions mocks base method +func (m *MockInspectorAPI) ListEventSubscriptions(arg0 *inspector.ListEventSubscriptionsInput) (*inspector.ListEventSubscriptionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListEventSubscriptions", arg0) + ret0, _ := ret[0].(*inspector.ListEventSubscriptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListEventSubscriptions indicates an expected call of ListEventSubscriptions +func (mr *MockInspectorAPIMockRecorder) ListEventSubscriptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventSubscriptions", reflect.TypeOf((*MockInspectorAPI)(nil).ListEventSubscriptions), arg0) +} + +// ListEventSubscriptionsPages mocks base method +func (m *MockInspectorAPI) ListEventSubscriptionsPages(arg0 *inspector.ListEventSubscriptionsInput, arg1 func(*inspector.ListEventSubscriptionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListEventSubscriptionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListEventSubscriptionsPages indicates an expected call of ListEventSubscriptionsPages +func (mr *MockInspectorAPIMockRecorder) ListEventSubscriptionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventSubscriptionsPages", reflect.TypeOf((*MockInspectorAPI)(nil).ListEventSubscriptionsPages), arg0, arg1) +} + +// ListEventSubscriptionsPagesWithContext mocks base method +func (m *MockInspectorAPI) ListEventSubscriptionsPagesWithContext(arg0 context.Context, arg1 *inspector.ListEventSubscriptionsInput, arg2 func(*inspector.ListEventSubscriptionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListEventSubscriptionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListEventSubscriptionsPagesWithContext indicates an expected call of ListEventSubscriptionsPagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListEventSubscriptionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventSubscriptionsPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListEventSubscriptionsPagesWithContext), varargs...) +} + +// ListEventSubscriptionsRequest mocks base method +func (m *MockInspectorAPI) ListEventSubscriptionsRequest(arg0 *inspector.ListEventSubscriptionsInput) (*request.Request, *inspector.ListEventSubscriptionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListEventSubscriptionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListEventSubscriptionsOutput) + return ret0, ret1 +} + +// ListEventSubscriptionsRequest indicates an expected call of ListEventSubscriptionsRequest +func (mr *MockInspectorAPIMockRecorder) ListEventSubscriptionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventSubscriptionsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListEventSubscriptionsRequest), arg0) +} + +// ListEventSubscriptionsWithContext mocks base method +func (m *MockInspectorAPI) ListEventSubscriptionsWithContext(arg0 context.Context, arg1 *inspector.ListEventSubscriptionsInput, arg2 ...request.Option) (*inspector.ListEventSubscriptionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListEventSubscriptionsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListEventSubscriptionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListEventSubscriptionsWithContext indicates an expected call of ListEventSubscriptionsWithContext +func (mr *MockInspectorAPIMockRecorder) ListEventSubscriptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEventSubscriptionsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListEventSubscriptionsWithContext), varargs...) +} + +// ListExclusions mocks base method +func (m *MockInspectorAPI) ListExclusions(arg0 *inspector.ListExclusionsInput) (*inspector.ListExclusionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListExclusions", arg0) + ret0, _ := ret[0].(*inspector.ListExclusionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListExclusions indicates an expected call of ListExclusions +func (mr *MockInspectorAPIMockRecorder) ListExclusions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExclusions", reflect.TypeOf((*MockInspectorAPI)(nil).ListExclusions), arg0) +} + +// ListExclusionsPages mocks base method +func (m *MockInspectorAPI) ListExclusionsPages(arg0 *inspector.ListExclusionsInput, arg1 func(*inspector.ListExclusionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListExclusionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListExclusionsPages indicates an expected call of ListExclusionsPages +func (mr *MockInspectorAPIMockRecorder) ListExclusionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExclusionsPages", reflect.TypeOf((*MockInspectorAPI)(nil).ListExclusionsPages), arg0, arg1) +} + +// ListExclusionsPagesWithContext mocks base method +func (m *MockInspectorAPI) ListExclusionsPagesWithContext(arg0 context.Context, arg1 *inspector.ListExclusionsInput, arg2 func(*inspector.ListExclusionsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListExclusionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListExclusionsPagesWithContext indicates an expected call of ListExclusionsPagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListExclusionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExclusionsPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListExclusionsPagesWithContext), varargs...) +} + +// ListExclusionsRequest mocks base method +func (m *MockInspectorAPI) ListExclusionsRequest(arg0 *inspector.ListExclusionsInput) (*request.Request, *inspector.ListExclusionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListExclusionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListExclusionsOutput) + return ret0, ret1 +} + +// ListExclusionsRequest indicates an expected call of ListExclusionsRequest +func (mr *MockInspectorAPIMockRecorder) ListExclusionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExclusionsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListExclusionsRequest), arg0) +} + +// ListExclusionsWithContext mocks base method +func (m *MockInspectorAPI) ListExclusionsWithContext(arg0 context.Context, arg1 *inspector.ListExclusionsInput, arg2 ...request.Option) (*inspector.ListExclusionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListExclusionsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListExclusionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListExclusionsWithContext indicates an expected call of ListExclusionsWithContext +func (mr *MockInspectorAPIMockRecorder) ListExclusionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExclusionsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListExclusionsWithContext), varargs...) +} + +// ListFindings mocks base method +func (m *MockInspectorAPI) ListFindings(arg0 *inspector.ListFindingsInput) (*inspector.ListFindingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFindings", arg0) + ret0, _ := ret[0].(*inspector.ListFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFindings indicates an expected call of ListFindings +func (mr *MockInspectorAPIMockRecorder) ListFindings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFindings", reflect.TypeOf((*MockInspectorAPI)(nil).ListFindings), arg0) +} + +// ListFindingsPages mocks base method +func (m *MockInspectorAPI) ListFindingsPages(arg0 *inspector.ListFindingsInput, arg1 func(*inspector.ListFindingsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFindingsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFindingsPages indicates an expected call of ListFindingsPages +func (mr *MockInspectorAPIMockRecorder) ListFindingsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFindingsPages", reflect.TypeOf((*MockInspectorAPI)(nil).ListFindingsPages), arg0, arg1) +} + +// ListFindingsPagesWithContext mocks base method +func (m *MockInspectorAPI) ListFindingsPagesWithContext(arg0 context.Context, arg1 *inspector.ListFindingsInput, arg2 func(*inspector.ListFindingsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFindingsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListFindingsPagesWithContext indicates an expected call of ListFindingsPagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListFindingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFindingsPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListFindingsPagesWithContext), varargs...) +} + +// ListFindingsRequest mocks base method +func (m *MockInspectorAPI) ListFindingsRequest(arg0 *inspector.ListFindingsInput) (*request.Request, *inspector.ListFindingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListFindingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListFindingsOutput) + return ret0, ret1 +} + +// ListFindingsRequest indicates an expected call of ListFindingsRequest +func (mr *MockInspectorAPIMockRecorder) ListFindingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFindingsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListFindingsRequest), arg0) +} + +// ListFindingsWithContext mocks base method +func (m *MockInspectorAPI) ListFindingsWithContext(arg0 context.Context, arg1 *inspector.ListFindingsInput, arg2 ...request.Option) (*inspector.ListFindingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListFindingsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListFindingsWithContext indicates an expected call of ListFindingsWithContext +func (mr *MockInspectorAPIMockRecorder) ListFindingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFindingsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListFindingsWithContext), varargs...) +} + +// ListRulesPackages mocks base method +func (m *MockInspectorAPI) ListRulesPackages(arg0 *inspector.ListRulesPackagesInput) (*inspector.ListRulesPackagesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRulesPackages", arg0) + ret0, _ := ret[0].(*inspector.ListRulesPackagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRulesPackages indicates an expected call of ListRulesPackages +func (mr *MockInspectorAPIMockRecorder) ListRulesPackages(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRulesPackages", reflect.TypeOf((*MockInspectorAPI)(nil).ListRulesPackages), arg0) +} + +// ListRulesPackagesPages mocks base method +func (m *MockInspectorAPI) ListRulesPackagesPages(arg0 *inspector.ListRulesPackagesInput, arg1 func(*inspector.ListRulesPackagesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRulesPackagesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRulesPackagesPages indicates an expected call of ListRulesPackagesPages +func (mr *MockInspectorAPIMockRecorder) ListRulesPackagesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRulesPackagesPages", reflect.TypeOf((*MockInspectorAPI)(nil).ListRulesPackagesPages), arg0, arg1) +} + +// ListRulesPackagesPagesWithContext mocks base method +func (m *MockInspectorAPI) ListRulesPackagesPagesWithContext(arg0 context.Context, arg1 *inspector.ListRulesPackagesInput, arg2 func(*inspector.ListRulesPackagesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRulesPackagesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRulesPackagesPagesWithContext indicates an expected call of ListRulesPackagesPagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListRulesPackagesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRulesPackagesPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListRulesPackagesPagesWithContext), varargs...) +} + +// ListRulesPackagesRequest mocks base method +func (m *MockInspectorAPI) ListRulesPackagesRequest(arg0 *inspector.ListRulesPackagesInput) (*request.Request, *inspector.ListRulesPackagesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRulesPackagesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListRulesPackagesOutput) + return ret0, ret1 +} + +// ListRulesPackagesRequest indicates an expected call of ListRulesPackagesRequest +func (mr *MockInspectorAPIMockRecorder) ListRulesPackagesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRulesPackagesRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListRulesPackagesRequest), arg0) +} + +// ListRulesPackagesWithContext mocks base method +func (m *MockInspectorAPI) ListRulesPackagesWithContext(arg0 context.Context, arg1 *inspector.ListRulesPackagesInput, arg2 ...request.Option) (*inspector.ListRulesPackagesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRulesPackagesWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListRulesPackagesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRulesPackagesWithContext indicates an expected call of ListRulesPackagesWithContext +func (mr *MockInspectorAPIMockRecorder) ListRulesPackagesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRulesPackagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListRulesPackagesWithContext), varargs...) +} + +// ListTagsForResource mocks base method +func (m *MockInspectorAPI) ListTagsForResource(arg0 *inspector.ListTagsForResourceInput) (*inspector.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResource", arg0) + ret0, _ := ret[0].(*inspector.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResource indicates an expected call of ListTagsForResource +func (mr *MockInspectorAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockInspectorAPI)(nil).ListTagsForResource), arg0) +} + +// ListTagsForResourceRequest mocks base method +func (m *MockInspectorAPI) ListTagsForResourceRequest(arg0 *inspector.ListTagsForResourceInput) (*request.Request, *inspector.ListTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.ListTagsForResourceOutput) + return ret0, ret1 +} + +// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest +func (mr *MockInspectorAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockInspectorAPI)(nil).ListTagsForResourceRequest), arg0) +} + +// ListTagsForResourceWithContext mocks base method +func (m *MockInspectorAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *inspector.ListTagsForResourceInput, arg2 ...request.Option) (*inspector.ListTagsForResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) + ret0, _ := ret[0].(*inspector.ListTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext +func (mr *MockInspectorAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).ListTagsForResourceWithContext), varargs...) +} + +// PreviewAgents mocks base method +func (m *MockInspectorAPI) PreviewAgents(arg0 *inspector.PreviewAgentsInput) (*inspector.PreviewAgentsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PreviewAgents", arg0) + ret0, _ := ret[0].(*inspector.PreviewAgentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PreviewAgents indicates an expected call of PreviewAgents +func (mr *MockInspectorAPIMockRecorder) PreviewAgents(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviewAgents", reflect.TypeOf((*MockInspectorAPI)(nil).PreviewAgents), arg0) +} + +// PreviewAgentsPages mocks base method +func (m *MockInspectorAPI) PreviewAgentsPages(arg0 *inspector.PreviewAgentsInput, arg1 func(*inspector.PreviewAgentsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PreviewAgentsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// PreviewAgentsPages indicates an expected call of PreviewAgentsPages +func (mr *MockInspectorAPIMockRecorder) PreviewAgentsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviewAgentsPages", reflect.TypeOf((*MockInspectorAPI)(nil).PreviewAgentsPages), arg0, arg1) +} + +// PreviewAgentsPagesWithContext mocks base method +func (m *MockInspectorAPI) PreviewAgentsPagesWithContext(arg0 context.Context, arg1 *inspector.PreviewAgentsInput, arg2 func(*inspector.PreviewAgentsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PreviewAgentsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// PreviewAgentsPagesWithContext indicates an expected call of PreviewAgentsPagesWithContext +func (mr *MockInspectorAPIMockRecorder) PreviewAgentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviewAgentsPagesWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).PreviewAgentsPagesWithContext), varargs...) +} + +// PreviewAgentsRequest mocks base method +func (m *MockInspectorAPI) PreviewAgentsRequest(arg0 *inspector.PreviewAgentsInput) (*request.Request, *inspector.PreviewAgentsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PreviewAgentsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.PreviewAgentsOutput) + return ret0, ret1 +} + +// PreviewAgentsRequest indicates an expected call of PreviewAgentsRequest +func (mr *MockInspectorAPIMockRecorder) PreviewAgentsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviewAgentsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).PreviewAgentsRequest), arg0) +} + +// PreviewAgentsWithContext mocks base method +func (m *MockInspectorAPI) PreviewAgentsWithContext(arg0 context.Context, arg1 *inspector.PreviewAgentsInput, arg2 ...request.Option) (*inspector.PreviewAgentsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PreviewAgentsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.PreviewAgentsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PreviewAgentsWithContext indicates an expected call of PreviewAgentsWithContext +func (mr *MockInspectorAPIMockRecorder) PreviewAgentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviewAgentsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).PreviewAgentsWithContext), varargs...) +} + +// RegisterCrossAccountAccessRole mocks base method +func (m *MockInspectorAPI) RegisterCrossAccountAccessRole(arg0 *inspector.RegisterCrossAccountAccessRoleInput) (*inspector.RegisterCrossAccountAccessRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterCrossAccountAccessRole", arg0) + ret0, _ := ret[0].(*inspector.RegisterCrossAccountAccessRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterCrossAccountAccessRole indicates an expected call of RegisterCrossAccountAccessRole +func (mr *MockInspectorAPIMockRecorder) RegisterCrossAccountAccessRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCrossAccountAccessRole", reflect.TypeOf((*MockInspectorAPI)(nil).RegisterCrossAccountAccessRole), arg0) +} + +// RegisterCrossAccountAccessRoleRequest mocks base method +func (m *MockInspectorAPI) RegisterCrossAccountAccessRoleRequest(arg0 *inspector.RegisterCrossAccountAccessRoleInput) (*request.Request, *inspector.RegisterCrossAccountAccessRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterCrossAccountAccessRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.RegisterCrossAccountAccessRoleOutput) + return ret0, ret1 +} + +// RegisterCrossAccountAccessRoleRequest indicates an expected call of RegisterCrossAccountAccessRoleRequest +func (mr *MockInspectorAPIMockRecorder) RegisterCrossAccountAccessRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCrossAccountAccessRoleRequest", reflect.TypeOf((*MockInspectorAPI)(nil).RegisterCrossAccountAccessRoleRequest), arg0) +} + +// RegisterCrossAccountAccessRoleWithContext mocks base method +func (m *MockInspectorAPI) RegisterCrossAccountAccessRoleWithContext(arg0 context.Context, arg1 *inspector.RegisterCrossAccountAccessRoleInput, arg2 ...request.Option) (*inspector.RegisterCrossAccountAccessRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterCrossAccountAccessRoleWithContext", varargs...) + ret0, _ := ret[0].(*inspector.RegisterCrossAccountAccessRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterCrossAccountAccessRoleWithContext indicates an expected call of RegisterCrossAccountAccessRoleWithContext +func (mr *MockInspectorAPIMockRecorder) RegisterCrossAccountAccessRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCrossAccountAccessRoleWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).RegisterCrossAccountAccessRoleWithContext), varargs...) +} + +// RemoveAttributesFromFindings mocks base method +func (m *MockInspectorAPI) RemoveAttributesFromFindings(arg0 *inspector.RemoveAttributesFromFindingsInput) (*inspector.RemoveAttributesFromFindingsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAttributesFromFindings", arg0) + ret0, _ := ret[0].(*inspector.RemoveAttributesFromFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveAttributesFromFindings indicates an expected call of RemoveAttributesFromFindings +func (mr *MockInspectorAPIMockRecorder) RemoveAttributesFromFindings(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAttributesFromFindings", reflect.TypeOf((*MockInspectorAPI)(nil).RemoveAttributesFromFindings), arg0) +} + +// RemoveAttributesFromFindingsRequest mocks base method +func (m *MockInspectorAPI) RemoveAttributesFromFindingsRequest(arg0 *inspector.RemoveAttributesFromFindingsInput) (*request.Request, *inspector.RemoveAttributesFromFindingsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveAttributesFromFindingsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.RemoveAttributesFromFindingsOutput) + return ret0, ret1 +} + +// RemoveAttributesFromFindingsRequest indicates an expected call of RemoveAttributesFromFindingsRequest +func (mr *MockInspectorAPIMockRecorder) RemoveAttributesFromFindingsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAttributesFromFindingsRequest", reflect.TypeOf((*MockInspectorAPI)(nil).RemoveAttributesFromFindingsRequest), arg0) +} + +// RemoveAttributesFromFindingsWithContext mocks base method +func (m *MockInspectorAPI) RemoveAttributesFromFindingsWithContext(arg0 context.Context, arg1 *inspector.RemoveAttributesFromFindingsInput, arg2 ...request.Option) (*inspector.RemoveAttributesFromFindingsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RemoveAttributesFromFindingsWithContext", varargs...) + ret0, _ := ret[0].(*inspector.RemoveAttributesFromFindingsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveAttributesFromFindingsWithContext indicates an expected call of RemoveAttributesFromFindingsWithContext +func (mr *MockInspectorAPIMockRecorder) RemoveAttributesFromFindingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAttributesFromFindingsWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).RemoveAttributesFromFindingsWithContext), varargs...) +} + +// SetTagsForResource mocks base method +func (m *MockInspectorAPI) SetTagsForResource(arg0 *inspector.SetTagsForResourceInput) (*inspector.SetTagsForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetTagsForResource", arg0) + ret0, _ := ret[0].(*inspector.SetTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetTagsForResource indicates an expected call of SetTagsForResource +func (mr *MockInspectorAPIMockRecorder) SetTagsForResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTagsForResource", reflect.TypeOf((*MockInspectorAPI)(nil).SetTagsForResource), arg0) +} + +// SetTagsForResourceRequest mocks base method +func (m *MockInspectorAPI) SetTagsForResourceRequest(arg0 *inspector.SetTagsForResourceInput) (*request.Request, *inspector.SetTagsForResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetTagsForResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.SetTagsForResourceOutput) + return ret0, ret1 +} + +// SetTagsForResourceRequest indicates an expected call of SetTagsForResourceRequest +func (mr *MockInspectorAPIMockRecorder) SetTagsForResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTagsForResourceRequest", reflect.TypeOf((*MockInspectorAPI)(nil).SetTagsForResourceRequest), arg0) +} + +// SetTagsForResourceWithContext mocks base method +func (m *MockInspectorAPI) SetTagsForResourceWithContext(arg0 context.Context, arg1 *inspector.SetTagsForResourceInput, arg2 ...request.Option) (*inspector.SetTagsForResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetTagsForResourceWithContext", varargs...) + ret0, _ := ret[0].(*inspector.SetTagsForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetTagsForResourceWithContext indicates an expected call of SetTagsForResourceWithContext +func (mr *MockInspectorAPIMockRecorder) SetTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTagsForResourceWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).SetTagsForResourceWithContext), varargs...) +} + +// StartAssessmentRun mocks base method +func (m *MockInspectorAPI) StartAssessmentRun(arg0 *inspector.StartAssessmentRunInput) (*inspector.StartAssessmentRunOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartAssessmentRun", arg0) + ret0, _ := ret[0].(*inspector.StartAssessmentRunOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartAssessmentRun indicates an expected call of StartAssessmentRun +func (mr *MockInspectorAPIMockRecorder) StartAssessmentRun(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAssessmentRun", reflect.TypeOf((*MockInspectorAPI)(nil).StartAssessmentRun), arg0) +} + +// StartAssessmentRunRequest mocks base method +func (m *MockInspectorAPI) StartAssessmentRunRequest(arg0 *inspector.StartAssessmentRunInput) (*request.Request, *inspector.StartAssessmentRunOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartAssessmentRunRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.StartAssessmentRunOutput) + return ret0, ret1 +} + +// StartAssessmentRunRequest indicates an expected call of StartAssessmentRunRequest +func (mr *MockInspectorAPIMockRecorder) StartAssessmentRunRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAssessmentRunRequest", reflect.TypeOf((*MockInspectorAPI)(nil).StartAssessmentRunRequest), arg0) +} + +// StartAssessmentRunWithContext mocks base method +func (m *MockInspectorAPI) StartAssessmentRunWithContext(arg0 context.Context, arg1 *inspector.StartAssessmentRunInput, arg2 ...request.Option) (*inspector.StartAssessmentRunOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartAssessmentRunWithContext", varargs...) + ret0, _ := ret[0].(*inspector.StartAssessmentRunOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartAssessmentRunWithContext indicates an expected call of StartAssessmentRunWithContext +func (mr *MockInspectorAPIMockRecorder) StartAssessmentRunWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAssessmentRunWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).StartAssessmentRunWithContext), varargs...) +} + +// StopAssessmentRun mocks base method +func (m *MockInspectorAPI) StopAssessmentRun(arg0 *inspector.StopAssessmentRunInput) (*inspector.StopAssessmentRunOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopAssessmentRun", arg0) + ret0, _ := ret[0].(*inspector.StopAssessmentRunOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopAssessmentRun indicates an expected call of StopAssessmentRun +func (mr *MockInspectorAPIMockRecorder) StopAssessmentRun(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAssessmentRun", reflect.TypeOf((*MockInspectorAPI)(nil).StopAssessmentRun), arg0) +} + +// StopAssessmentRunRequest mocks base method +func (m *MockInspectorAPI) StopAssessmentRunRequest(arg0 *inspector.StopAssessmentRunInput) (*request.Request, *inspector.StopAssessmentRunOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StopAssessmentRunRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.StopAssessmentRunOutput) + return ret0, ret1 +} + +// StopAssessmentRunRequest indicates an expected call of StopAssessmentRunRequest +func (mr *MockInspectorAPIMockRecorder) StopAssessmentRunRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAssessmentRunRequest", reflect.TypeOf((*MockInspectorAPI)(nil).StopAssessmentRunRequest), arg0) +} + +// StopAssessmentRunWithContext mocks base method +func (m *MockInspectorAPI) StopAssessmentRunWithContext(arg0 context.Context, arg1 *inspector.StopAssessmentRunInput, arg2 ...request.Option) (*inspector.StopAssessmentRunOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StopAssessmentRunWithContext", varargs...) + ret0, _ := ret[0].(*inspector.StopAssessmentRunOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StopAssessmentRunWithContext indicates an expected call of StopAssessmentRunWithContext +func (mr *MockInspectorAPIMockRecorder) StopAssessmentRunWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopAssessmentRunWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).StopAssessmentRunWithContext), varargs...) +} + +// SubscribeToEvent mocks base method +func (m *MockInspectorAPI) SubscribeToEvent(arg0 *inspector.SubscribeToEventInput) (*inspector.SubscribeToEventOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SubscribeToEvent", arg0) + ret0, _ := ret[0].(*inspector.SubscribeToEventOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubscribeToEvent indicates an expected call of SubscribeToEvent +func (mr *MockInspectorAPIMockRecorder) SubscribeToEvent(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeToEvent", reflect.TypeOf((*MockInspectorAPI)(nil).SubscribeToEvent), arg0) +} + +// SubscribeToEventRequest mocks base method +func (m *MockInspectorAPI) SubscribeToEventRequest(arg0 *inspector.SubscribeToEventInput) (*request.Request, *inspector.SubscribeToEventOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SubscribeToEventRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.SubscribeToEventOutput) + return ret0, ret1 +} + +// SubscribeToEventRequest indicates an expected call of SubscribeToEventRequest +func (mr *MockInspectorAPIMockRecorder) SubscribeToEventRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeToEventRequest", reflect.TypeOf((*MockInspectorAPI)(nil).SubscribeToEventRequest), arg0) +} + +// SubscribeToEventWithContext mocks base method +func (m *MockInspectorAPI) SubscribeToEventWithContext(arg0 context.Context, arg1 *inspector.SubscribeToEventInput, arg2 ...request.Option) (*inspector.SubscribeToEventOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SubscribeToEventWithContext", varargs...) + ret0, _ := ret[0].(*inspector.SubscribeToEventOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SubscribeToEventWithContext indicates an expected call of SubscribeToEventWithContext +func (mr *MockInspectorAPIMockRecorder) SubscribeToEventWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeToEventWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).SubscribeToEventWithContext), varargs...) +} + +// UnsubscribeFromEvent mocks base method +func (m *MockInspectorAPI) UnsubscribeFromEvent(arg0 *inspector.UnsubscribeFromEventInput) (*inspector.UnsubscribeFromEventOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnsubscribeFromEvent", arg0) + ret0, _ := ret[0].(*inspector.UnsubscribeFromEventOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnsubscribeFromEvent indicates an expected call of UnsubscribeFromEvent +func (mr *MockInspectorAPIMockRecorder) UnsubscribeFromEvent(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeFromEvent", reflect.TypeOf((*MockInspectorAPI)(nil).UnsubscribeFromEvent), arg0) +} + +// UnsubscribeFromEventRequest mocks base method +func (m *MockInspectorAPI) UnsubscribeFromEventRequest(arg0 *inspector.UnsubscribeFromEventInput) (*request.Request, *inspector.UnsubscribeFromEventOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnsubscribeFromEventRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.UnsubscribeFromEventOutput) + return ret0, ret1 +} + +// UnsubscribeFromEventRequest indicates an expected call of UnsubscribeFromEventRequest +func (mr *MockInspectorAPIMockRecorder) UnsubscribeFromEventRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeFromEventRequest", reflect.TypeOf((*MockInspectorAPI)(nil).UnsubscribeFromEventRequest), arg0) +} + +// UnsubscribeFromEventWithContext mocks base method +func (m *MockInspectorAPI) UnsubscribeFromEventWithContext(arg0 context.Context, arg1 *inspector.UnsubscribeFromEventInput, arg2 ...request.Option) (*inspector.UnsubscribeFromEventOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnsubscribeFromEventWithContext", varargs...) + ret0, _ := ret[0].(*inspector.UnsubscribeFromEventOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnsubscribeFromEventWithContext indicates an expected call of UnsubscribeFromEventWithContext +func (mr *MockInspectorAPIMockRecorder) UnsubscribeFromEventWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeFromEventWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).UnsubscribeFromEventWithContext), varargs...) +} + +// UpdateAssessmentTarget mocks base method +func (m *MockInspectorAPI) UpdateAssessmentTarget(arg0 *inspector.UpdateAssessmentTargetInput) (*inspector.UpdateAssessmentTargetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAssessmentTarget", arg0) + ret0, _ := ret[0].(*inspector.UpdateAssessmentTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAssessmentTarget indicates an expected call of UpdateAssessmentTarget +func (mr *MockInspectorAPIMockRecorder) UpdateAssessmentTarget(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssessmentTarget", reflect.TypeOf((*MockInspectorAPI)(nil).UpdateAssessmentTarget), arg0) +} + +// UpdateAssessmentTargetRequest mocks base method +func (m *MockInspectorAPI) UpdateAssessmentTargetRequest(arg0 *inspector.UpdateAssessmentTargetInput) (*request.Request, *inspector.UpdateAssessmentTargetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAssessmentTargetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*inspector.UpdateAssessmentTargetOutput) + return ret0, ret1 +} + +// UpdateAssessmentTargetRequest indicates an expected call of UpdateAssessmentTargetRequest +func (mr *MockInspectorAPIMockRecorder) UpdateAssessmentTargetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssessmentTargetRequest", reflect.TypeOf((*MockInspectorAPI)(nil).UpdateAssessmentTargetRequest), arg0) +} + +// UpdateAssessmentTargetWithContext mocks base method +func (m *MockInspectorAPI) UpdateAssessmentTargetWithContext(arg0 context.Context, arg1 *inspector.UpdateAssessmentTargetInput, arg2 ...request.Option) (*inspector.UpdateAssessmentTargetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateAssessmentTargetWithContext", varargs...) + ret0, _ := ret[0].(*inspector.UpdateAssessmentTargetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAssessmentTargetWithContext indicates an expected call of UpdateAssessmentTargetWithContext +func (mr *MockInspectorAPIMockRecorder) UpdateAssessmentTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAssessmentTargetWithContext", reflect.TypeOf((*MockInspectorAPI)(nil).UpdateAssessmentTargetWithContext), varargs...) +} diff --git a/pkg/mocks/mock_sts.go b/pkg/mocks/mock_sts.go new file mode 100644 index 0000000..d712700 --- /dev/null +++ b/pkg/mocks/mock_sts.go @@ -0,0 +1,436 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/sts/stsiface (interfaces: STSAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + sts "github.com/aws/aws-sdk-go/service/sts" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockSTSAPI is a mock of STSAPI interface +type MockSTSAPI struct { + ctrl *gomock.Controller + recorder *MockSTSAPIMockRecorder +} + +// MockSTSAPIMockRecorder is the mock recorder for MockSTSAPI +type MockSTSAPIMockRecorder struct { + mock *MockSTSAPI +} + +// NewMockSTSAPI creates a new mock instance +func NewMockSTSAPI(ctrl *gomock.Controller) *MockSTSAPI { + mock := &MockSTSAPI{ctrl: ctrl} + mock.recorder = &MockSTSAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockSTSAPI) EXPECT() *MockSTSAPIMockRecorder { + return m.recorder +} + +// AssumeRole mocks base method +func (m *MockSTSAPI) AssumeRole(arg0 *sts.AssumeRoleInput) (*sts.AssumeRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRole", arg0) + ret0, _ := ret[0].(*sts.AssumeRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRole indicates an expected call of AssumeRole +func (mr *MockSTSAPIMockRecorder) AssumeRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRole", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRole), arg0) +} + +// AssumeRoleRequest mocks base method +func (m *MockSTSAPI) AssumeRoleRequest(arg0 *sts.AssumeRoleInput) (*request.Request, *sts.AssumeRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.AssumeRoleOutput) + return ret0, ret1 +} + +// AssumeRoleRequest indicates an expected call of AssumeRoleRequest +func (mr *MockSTSAPIMockRecorder) AssumeRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleRequest), arg0) +} + +// AssumeRoleWithContext mocks base method +func (m *MockSTSAPI) AssumeRoleWithContext(arg0 context.Context, arg1 *sts.AssumeRoleInput, arg2 ...request.Option) (*sts.AssumeRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssumeRoleWithContext", varargs...) + ret0, _ := ret[0].(*sts.AssumeRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithContext indicates an expected call of AssumeRoleWithContext +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithContext), varargs...) +} + +// AssumeRoleWithSAML mocks base method +func (m *MockSTSAPI) AssumeRoleWithSAML(arg0 *sts.AssumeRoleWithSAMLInput) (*sts.AssumeRoleWithSAMLOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleWithSAML", arg0) + ret0, _ := ret[0].(*sts.AssumeRoleWithSAMLOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithSAML indicates an expected call of AssumeRoleWithSAML +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAML(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAML", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAML), arg0) +} + +// AssumeRoleWithSAMLRequest mocks base method +func (m *MockSTSAPI) AssumeRoleWithSAMLRequest(arg0 *sts.AssumeRoleWithSAMLInput) (*request.Request, *sts.AssumeRoleWithSAMLOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleWithSAMLRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.AssumeRoleWithSAMLOutput) + return ret0, ret1 +} + +// AssumeRoleWithSAMLRequest indicates an expected call of AssumeRoleWithSAMLRequest +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAMLRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAMLRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAMLRequest), arg0) +} + +// AssumeRoleWithSAMLWithContext mocks base method +func (m *MockSTSAPI) AssumeRoleWithSAMLWithContext(arg0 context.Context, arg1 *sts.AssumeRoleWithSAMLInput, arg2 ...request.Option) (*sts.AssumeRoleWithSAMLOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssumeRoleWithSAMLWithContext", varargs...) + ret0, _ := ret[0].(*sts.AssumeRoleWithSAMLOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithSAMLWithContext indicates an expected call of AssumeRoleWithSAMLWithContext +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAMLWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAMLWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAMLWithContext), varargs...) +} + +// AssumeRoleWithWebIdentity mocks base method +func (m *MockSTSAPI) AssumeRoleWithWebIdentity(arg0 *sts.AssumeRoleWithWebIdentityInput) (*sts.AssumeRoleWithWebIdentityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentity", arg0) + ret0, _ := ret[0].(*sts.AssumeRoleWithWebIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithWebIdentity indicates an expected call of AssumeRoleWithWebIdentity +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentity", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentity), arg0) +} + +// AssumeRoleWithWebIdentityRequest mocks base method +func (m *MockSTSAPI) AssumeRoleWithWebIdentityRequest(arg0 *sts.AssumeRoleWithWebIdentityInput) (*request.Request, *sts.AssumeRoleWithWebIdentityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.AssumeRoleWithWebIdentityOutput) + return ret0, ret1 +} + +// AssumeRoleWithWebIdentityRequest indicates an expected call of AssumeRoleWithWebIdentityRequest +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentityRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentityRequest), arg0) +} + +// AssumeRoleWithWebIdentityWithContext mocks base method +func (m *MockSTSAPI) AssumeRoleWithWebIdentityWithContext(arg0 context.Context, arg1 *sts.AssumeRoleWithWebIdentityInput, arg2 ...request.Option) (*sts.AssumeRoleWithWebIdentityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentityWithContext", varargs...) + ret0, _ := ret[0].(*sts.AssumeRoleWithWebIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithWebIdentityWithContext indicates an expected call of AssumeRoleWithWebIdentityWithContext +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentityWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentityWithContext), varargs...) +} + +// DecodeAuthorizationMessage mocks base method +func (m *MockSTSAPI) DecodeAuthorizationMessage(arg0 *sts.DecodeAuthorizationMessageInput) (*sts.DecodeAuthorizationMessageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecodeAuthorizationMessage", arg0) + ret0, _ := ret[0].(*sts.DecodeAuthorizationMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DecodeAuthorizationMessage indicates an expected call of DecodeAuthorizationMessage +func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessage", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessage), arg0) +} + +// DecodeAuthorizationMessageRequest mocks base method +func (m *MockSTSAPI) DecodeAuthorizationMessageRequest(arg0 *sts.DecodeAuthorizationMessageInput) (*request.Request, *sts.DecodeAuthorizationMessageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecodeAuthorizationMessageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.DecodeAuthorizationMessageOutput) + return ret0, ret1 +} + +// DecodeAuthorizationMessageRequest indicates an expected call of DecodeAuthorizationMessageRequest +func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessageRequest", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessageRequest), arg0) +} + +// DecodeAuthorizationMessageWithContext mocks base method +func (m *MockSTSAPI) DecodeAuthorizationMessageWithContext(arg0 context.Context, arg1 *sts.DecodeAuthorizationMessageInput, arg2 ...request.Option) (*sts.DecodeAuthorizationMessageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DecodeAuthorizationMessageWithContext", varargs...) + ret0, _ := ret[0].(*sts.DecodeAuthorizationMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DecodeAuthorizationMessageWithContext indicates an expected call of DecodeAuthorizationMessageWithContext +func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessageWithContext", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessageWithContext), varargs...) +} + +// GetAccessKeyInfo mocks base method +func (m *MockSTSAPI) GetAccessKeyInfo(arg0 *sts.GetAccessKeyInfoInput) (*sts.GetAccessKeyInfoOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccessKeyInfo", arg0) + ret0, _ := ret[0].(*sts.GetAccessKeyInfoOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccessKeyInfo indicates an expected call of GetAccessKeyInfo +func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfo(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfo", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfo), arg0) +} + +// GetAccessKeyInfoRequest mocks base method +func (m *MockSTSAPI) GetAccessKeyInfoRequest(arg0 *sts.GetAccessKeyInfoInput) (*request.Request, *sts.GetAccessKeyInfoOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccessKeyInfoRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.GetAccessKeyInfoOutput) + return ret0, ret1 +} + +// GetAccessKeyInfoRequest indicates an expected call of GetAccessKeyInfoRequest +func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfoRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfoRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfoRequest), arg0) +} + +// GetAccessKeyInfoWithContext mocks base method +func (m *MockSTSAPI) GetAccessKeyInfoWithContext(arg0 context.Context, arg1 *sts.GetAccessKeyInfoInput, arg2 ...request.Option) (*sts.GetAccessKeyInfoOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAccessKeyInfoWithContext", varargs...) + ret0, _ := ret[0].(*sts.GetAccessKeyInfoOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccessKeyInfoWithContext indicates an expected call of GetAccessKeyInfoWithContext +func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfoWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfoWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfoWithContext), varargs...) +} + +// GetCallerIdentity mocks base method +func (m *MockSTSAPI) GetCallerIdentity(arg0 *sts.GetCallerIdentityInput) (*sts.GetCallerIdentityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCallerIdentity", arg0) + ret0, _ := ret[0].(*sts.GetCallerIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCallerIdentity indicates an expected call of GetCallerIdentity +func (mr *MockSTSAPIMockRecorder) GetCallerIdentity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentity", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentity), arg0) +} + +// GetCallerIdentityRequest mocks base method +func (m *MockSTSAPI) GetCallerIdentityRequest(arg0 *sts.GetCallerIdentityInput) (*request.Request, *sts.GetCallerIdentityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCallerIdentityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.GetCallerIdentityOutput) + return ret0, ret1 +} + +// GetCallerIdentityRequest indicates an expected call of GetCallerIdentityRequest +func (mr *MockSTSAPIMockRecorder) GetCallerIdentityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentityRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentityRequest), arg0) +} + +// GetCallerIdentityWithContext mocks base method +func (m *MockSTSAPI) GetCallerIdentityWithContext(arg0 context.Context, arg1 *sts.GetCallerIdentityInput, arg2 ...request.Option) (*sts.GetCallerIdentityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetCallerIdentityWithContext", varargs...) + ret0, _ := ret[0].(*sts.GetCallerIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCallerIdentityWithContext indicates an expected call of GetCallerIdentityWithContext +func (mr *MockSTSAPIMockRecorder) GetCallerIdentityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentityWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentityWithContext), varargs...) +} + +// GetFederationToken mocks base method +func (m *MockSTSAPI) GetFederationToken(arg0 *sts.GetFederationTokenInput) (*sts.GetFederationTokenOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFederationToken", arg0) + ret0, _ := ret[0].(*sts.GetFederationTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFederationToken indicates an expected call of GetFederationToken +func (mr *MockSTSAPIMockRecorder) GetFederationToken(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationToken", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationToken), arg0) +} + +// GetFederationTokenRequest mocks base method +func (m *MockSTSAPI) GetFederationTokenRequest(arg0 *sts.GetFederationTokenInput) (*request.Request, *sts.GetFederationTokenOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFederationTokenRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.GetFederationTokenOutput) + return ret0, ret1 +} + +// GetFederationTokenRequest indicates an expected call of GetFederationTokenRequest +func (mr *MockSTSAPIMockRecorder) GetFederationTokenRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationTokenRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationTokenRequest), arg0) +} + +// GetFederationTokenWithContext mocks base method +func (m *MockSTSAPI) GetFederationTokenWithContext(arg0 context.Context, arg1 *sts.GetFederationTokenInput, arg2 ...request.Option) (*sts.GetFederationTokenOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetFederationTokenWithContext", varargs...) + ret0, _ := ret[0].(*sts.GetFederationTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFederationTokenWithContext indicates an expected call of GetFederationTokenWithContext +func (mr *MockSTSAPIMockRecorder) GetFederationTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationTokenWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationTokenWithContext), varargs...) +} + +// GetSessionToken mocks base method +func (m *MockSTSAPI) GetSessionToken(arg0 *sts.GetSessionTokenInput) (*sts.GetSessionTokenOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSessionToken", arg0) + ret0, _ := ret[0].(*sts.GetSessionTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSessionToken indicates an expected call of GetSessionToken +func (mr *MockSTSAPIMockRecorder) GetSessionToken(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionToken", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionToken), arg0) +} + +// GetSessionTokenRequest mocks base method +func (m *MockSTSAPI) GetSessionTokenRequest(arg0 *sts.GetSessionTokenInput) (*request.Request, *sts.GetSessionTokenOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSessionTokenRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.GetSessionTokenOutput) + return ret0, ret1 +} + +// GetSessionTokenRequest indicates an expected call of GetSessionTokenRequest +func (mr *MockSTSAPIMockRecorder) GetSessionTokenRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionTokenRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionTokenRequest), arg0) +} + +// GetSessionTokenWithContext mocks base method +func (m *MockSTSAPI) GetSessionTokenWithContext(arg0 context.Context, arg1 *sts.GetSessionTokenInput, arg2 ...request.Option) (*sts.GetSessionTokenOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetSessionTokenWithContext", varargs...) + ret0, _ := ret[0].(*sts.GetSessionTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSessionTokenWithContext indicates an expected call of GetSessionTokenWithContext +func (mr *MockSTSAPIMockRecorder) GetSessionTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionTokenWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionTokenWithContext), varargs...) +} diff --git a/pkg/mocks/mock_trustedadvisor.go b/pkg/mocks/mock_trustedadvisor.go new file mode 100644 index 0000000..a5ca004 --- /dev/null +++ b/pkg/mocks/mock_trustedadvisor.go @@ -0,0 +1,802 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/support/supportiface (interfaces: SupportAPI) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + request "github.com/aws/aws-sdk-go/aws/request" + support "github.com/aws/aws-sdk-go/service/support" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockSupportAPI is a mock of SupportAPI interface +type MockSupportAPI struct { + ctrl *gomock.Controller + recorder *MockSupportAPIMockRecorder +} + +// MockSupportAPIMockRecorder is the mock recorder for MockSupportAPI +type MockSupportAPIMockRecorder struct { + mock *MockSupportAPI +} + +// NewMockSupportAPI creates a new mock instance +func NewMockSupportAPI(ctrl *gomock.Controller) *MockSupportAPI { + mock := &MockSupportAPI{ctrl: ctrl} + mock.recorder = &MockSupportAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockSupportAPI) EXPECT() *MockSupportAPIMockRecorder { + return m.recorder +} + +// AddAttachmentsToSet mocks base method +func (m *MockSupportAPI) AddAttachmentsToSet(arg0 *support.AddAttachmentsToSetInput) (*support.AddAttachmentsToSetOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddAttachmentsToSet", arg0) + ret0, _ := ret[0].(*support.AddAttachmentsToSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddAttachmentsToSet indicates an expected call of AddAttachmentsToSet +func (mr *MockSupportAPIMockRecorder) AddAttachmentsToSet(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAttachmentsToSet", reflect.TypeOf((*MockSupportAPI)(nil).AddAttachmentsToSet), arg0) +} + +// AddAttachmentsToSetRequest mocks base method +func (m *MockSupportAPI) AddAttachmentsToSetRequest(arg0 *support.AddAttachmentsToSetInput) (*request.Request, *support.AddAttachmentsToSetOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddAttachmentsToSetRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.AddAttachmentsToSetOutput) + return ret0, ret1 +} + +// AddAttachmentsToSetRequest indicates an expected call of AddAttachmentsToSetRequest +func (mr *MockSupportAPIMockRecorder) AddAttachmentsToSetRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAttachmentsToSetRequest", reflect.TypeOf((*MockSupportAPI)(nil).AddAttachmentsToSetRequest), arg0) +} + +// AddAttachmentsToSetWithContext mocks base method +func (m *MockSupportAPI) AddAttachmentsToSetWithContext(arg0 context.Context, arg1 *support.AddAttachmentsToSetInput, arg2 ...request.Option) (*support.AddAttachmentsToSetOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddAttachmentsToSetWithContext", varargs...) + ret0, _ := ret[0].(*support.AddAttachmentsToSetOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddAttachmentsToSetWithContext indicates an expected call of AddAttachmentsToSetWithContext +func (mr *MockSupportAPIMockRecorder) AddAttachmentsToSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAttachmentsToSetWithContext", reflect.TypeOf((*MockSupportAPI)(nil).AddAttachmentsToSetWithContext), varargs...) +} + +// AddCommunicationToCase mocks base method +func (m *MockSupportAPI) AddCommunicationToCase(arg0 *support.AddCommunicationToCaseInput) (*support.AddCommunicationToCaseOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddCommunicationToCase", arg0) + ret0, _ := ret[0].(*support.AddCommunicationToCaseOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddCommunicationToCase indicates an expected call of AddCommunicationToCase +func (mr *MockSupportAPIMockRecorder) AddCommunicationToCase(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCommunicationToCase", reflect.TypeOf((*MockSupportAPI)(nil).AddCommunicationToCase), arg0) +} + +// AddCommunicationToCaseRequest mocks base method +func (m *MockSupportAPI) AddCommunicationToCaseRequest(arg0 *support.AddCommunicationToCaseInput) (*request.Request, *support.AddCommunicationToCaseOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddCommunicationToCaseRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.AddCommunicationToCaseOutput) + return ret0, ret1 +} + +// AddCommunicationToCaseRequest indicates an expected call of AddCommunicationToCaseRequest +func (mr *MockSupportAPIMockRecorder) AddCommunicationToCaseRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCommunicationToCaseRequest", reflect.TypeOf((*MockSupportAPI)(nil).AddCommunicationToCaseRequest), arg0) +} + +// AddCommunicationToCaseWithContext mocks base method +func (m *MockSupportAPI) AddCommunicationToCaseWithContext(arg0 context.Context, arg1 *support.AddCommunicationToCaseInput, arg2 ...request.Option) (*support.AddCommunicationToCaseOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddCommunicationToCaseWithContext", varargs...) + ret0, _ := ret[0].(*support.AddCommunicationToCaseOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddCommunicationToCaseWithContext indicates an expected call of AddCommunicationToCaseWithContext +func (mr *MockSupportAPIMockRecorder) AddCommunicationToCaseWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCommunicationToCaseWithContext", reflect.TypeOf((*MockSupportAPI)(nil).AddCommunicationToCaseWithContext), varargs...) +} + +// CreateCase mocks base method +func (m *MockSupportAPI) CreateCase(arg0 *support.CreateCaseInput) (*support.CreateCaseOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCase", arg0) + ret0, _ := ret[0].(*support.CreateCaseOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCase indicates an expected call of CreateCase +func (mr *MockSupportAPIMockRecorder) CreateCase(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCase", reflect.TypeOf((*MockSupportAPI)(nil).CreateCase), arg0) +} + +// CreateCaseRequest mocks base method +func (m *MockSupportAPI) CreateCaseRequest(arg0 *support.CreateCaseInput) (*request.Request, *support.CreateCaseOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCaseRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.CreateCaseOutput) + return ret0, ret1 +} + +// CreateCaseRequest indicates an expected call of CreateCaseRequest +func (mr *MockSupportAPIMockRecorder) CreateCaseRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCaseRequest", reflect.TypeOf((*MockSupportAPI)(nil).CreateCaseRequest), arg0) +} + +// CreateCaseWithContext mocks base method +func (m *MockSupportAPI) CreateCaseWithContext(arg0 context.Context, arg1 *support.CreateCaseInput, arg2 ...request.Option) (*support.CreateCaseOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateCaseWithContext", varargs...) + ret0, _ := ret[0].(*support.CreateCaseOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCaseWithContext indicates an expected call of CreateCaseWithContext +func (mr *MockSupportAPIMockRecorder) CreateCaseWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCaseWithContext", reflect.TypeOf((*MockSupportAPI)(nil).CreateCaseWithContext), varargs...) +} + +// DescribeAttachment mocks base method +func (m *MockSupportAPI) DescribeAttachment(arg0 *support.DescribeAttachmentInput) (*support.DescribeAttachmentOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAttachment", arg0) + ret0, _ := ret[0].(*support.DescribeAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAttachment indicates an expected call of DescribeAttachment +func (mr *MockSupportAPIMockRecorder) DescribeAttachment(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAttachment", reflect.TypeOf((*MockSupportAPI)(nil).DescribeAttachment), arg0) +} + +// DescribeAttachmentRequest mocks base method +func (m *MockSupportAPI) DescribeAttachmentRequest(arg0 *support.DescribeAttachmentInput) (*request.Request, *support.DescribeAttachmentOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAttachmentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeAttachmentOutput) + return ret0, ret1 +} + +// DescribeAttachmentRequest indicates an expected call of DescribeAttachmentRequest +func (mr *MockSupportAPIMockRecorder) DescribeAttachmentRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAttachmentRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeAttachmentRequest), arg0) +} + +// DescribeAttachmentWithContext mocks base method +func (m *MockSupportAPI) DescribeAttachmentWithContext(arg0 context.Context, arg1 *support.DescribeAttachmentInput, arg2 ...request.Option) (*support.DescribeAttachmentOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAttachmentWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeAttachmentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAttachmentWithContext indicates an expected call of DescribeAttachmentWithContext +func (mr *MockSupportAPIMockRecorder) DescribeAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAttachmentWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeAttachmentWithContext), varargs...) +} + +// DescribeCases mocks base method +func (m *MockSupportAPI) DescribeCases(arg0 *support.DescribeCasesInput) (*support.DescribeCasesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCases", arg0) + ret0, _ := ret[0].(*support.DescribeCasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCases indicates an expected call of DescribeCases +func (mr *MockSupportAPIMockRecorder) DescribeCases(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCases", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCases), arg0) +} + +// DescribeCasesPages mocks base method +func (m *MockSupportAPI) DescribeCasesPages(arg0 *support.DescribeCasesInput, arg1 func(*support.DescribeCasesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCasesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCasesPages indicates an expected call of DescribeCasesPages +func (mr *MockSupportAPIMockRecorder) DescribeCasesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCasesPages", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCasesPages), arg0, arg1) +} + +// DescribeCasesPagesWithContext mocks base method +func (m *MockSupportAPI) DescribeCasesPagesWithContext(arg0 context.Context, arg1 *support.DescribeCasesInput, arg2 func(*support.DescribeCasesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCasesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCasesPagesWithContext indicates an expected call of DescribeCasesPagesWithContext +func (mr *MockSupportAPIMockRecorder) DescribeCasesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCasesPagesWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCasesPagesWithContext), varargs...) +} + +// DescribeCasesRequest mocks base method +func (m *MockSupportAPI) DescribeCasesRequest(arg0 *support.DescribeCasesInput) (*request.Request, *support.DescribeCasesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCasesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeCasesOutput) + return ret0, ret1 +} + +// DescribeCasesRequest indicates an expected call of DescribeCasesRequest +func (mr *MockSupportAPIMockRecorder) DescribeCasesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCasesRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCasesRequest), arg0) +} + +// DescribeCasesWithContext mocks base method +func (m *MockSupportAPI) DescribeCasesWithContext(arg0 context.Context, arg1 *support.DescribeCasesInput, arg2 ...request.Option) (*support.DescribeCasesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCasesWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeCasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCasesWithContext indicates an expected call of DescribeCasesWithContext +func (mr *MockSupportAPIMockRecorder) DescribeCasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCasesWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCasesWithContext), varargs...) +} + +// DescribeCommunications mocks base method +func (m *MockSupportAPI) DescribeCommunications(arg0 *support.DescribeCommunicationsInput) (*support.DescribeCommunicationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCommunications", arg0) + ret0, _ := ret[0].(*support.DescribeCommunicationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCommunications indicates an expected call of DescribeCommunications +func (mr *MockSupportAPIMockRecorder) DescribeCommunications(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCommunications", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCommunications), arg0) +} + +// DescribeCommunicationsPages mocks base method +func (m *MockSupportAPI) DescribeCommunicationsPages(arg0 *support.DescribeCommunicationsInput, arg1 func(*support.DescribeCommunicationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCommunicationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCommunicationsPages indicates an expected call of DescribeCommunicationsPages +func (mr *MockSupportAPIMockRecorder) DescribeCommunicationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCommunicationsPages", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCommunicationsPages), arg0, arg1) +} + +// DescribeCommunicationsPagesWithContext mocks base method +func (m *MockSupportAPI) DescribeCommunicationsPagesWithContext(arg0 context.Context, arg1 *support.DescribeCommunicationsInput, arg2 func(*support.DescribeCommunicationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCommunicationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCommunicationsPagesWithContext indicates an expected call of DescribeCommunicationsPagesWithContext +func (mr *MockSupportAPIMockRecorder) DescribeCommunicationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCommunicationsPagesWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCommunicationsPagesWithContext), varargs...) +} + +// DescribeCommunicationsRequest mocks base method +func (m *MockSupportAPI) DescribeCommunicationsRequest(arg0 *support.DescribeCommunicationsInput) (*request.Request, *support.DescribeCommunicationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCommunicationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeCommunicationsOutput) + return ret0, ret1 +} + +// DescribeCommunicationsRequest indicates an expected call of DescribeCommunicationsRequest +func (mr *MockSupportAPIMockRecorder) DescribeCommunicationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCommunicationsRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCommunicationsRequest), arg0) +} + +// DescribeCommunicationsWithContext mocks base method +func (m *MockSupportAPI) DescribeCommunicationsWithContext(arg0 context.Context, arg1 *support.DescribeCommunicationsInput, arg2 ...request.Option) (*support.DescribeCommunicationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCommunicationsWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeCommunicationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCommunicationsWithContext indicates an expected call of DescribeCommunicationsWithContext +func (mr *MockSupportAPIMockRecorder) DescribeCommunicationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCommunicationsWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeCommunicationsWithContext), varargs...) +} + +// DescribeServices mocks base method +func (m *MockSupportAPI) DescribeServices(arg0 *support.DescribeServicesInput) (*support.DescribeServicesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeServices", arg0) + ret0, _ := ret[0].(*support.DescribeServicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeServices indicates an expected call of DescribeServices +func (mr *MockSupportAPIMockRecorder) DescribeServices(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServices", reflect.TypeOf((*MockSupportAPI)(nil).DescribeServices), arg0) +} + +// DescribeServicesRequest mocks base method +func (m *MockSupportAPI) DescribeServicesRequest(arg0 *support.DescribeServicesInput) (*request.Request, *support.DescribeServicesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeServicesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeServicesOutput) + return ret0, ret1 +} + +// DescribeServicesRequest indicates an expected call of DescribeServicesRequest +func (mr *MockSupportAPIMockRecorder) DescribeServicesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServicesRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeServicesRequest), arg0) +} + +// DescribeServicesWithContext mocks base method +func (m *MockSupportAPI) DescribeServicesWithContext(arg0 context.Context, arg1 *support.DescribeServicesInput, arg2 ...request.Option) (*support.DescribeServicesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeServicesWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeServicesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeServicesWithContext indicates an expected call of DescribeServicesWithContext +func (mr *MockSupportAPIMockRecorder) DescribeServicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeServicesWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeServicesWithContext), varargs...) +} + +// DescribeSeverityLevels mocks base method +func (m *MockSupportAPI) DescribeSeverityLevels(arg0 *support.DescribeSeverityLevelsInput) (*support.DescribeSeverityLevelsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSeverityLevels", arg0) + ret0, _ := ret[0].(*support.DescribeSeverityLevelsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSeverityLevels indicates an expected call of DescribeSeverityLevels +func (mr *MockSupportAPIMockRecorder) DescribeSeverityLevels(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSeverityLevels", reflect.TypeOf((*MockSupportAPI)(nil).DescribeSeverityLevels), arg0) +} + +// DescribeSeverityLevelsRequest mocks base method +func (m *MockSupportAPI) DescribeSeverityLevelsRequest(arg0 *support.DescribeSeverityLevelsInput) (*request.Request, *support.DescribeSeverityLevelsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeSeverityLevelsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeSeverityLevelsOutput) + return ret0, ret1 +} + +// DescribeSeverityLevelsRequest indicates an expected call of DescribeSeverityLevelsRequest +func (mr *MockSupportAPIMockRecorder) DescribeSeverityLevelsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSeverityLevelsRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeSeverityLevelsRequest), arg0) +} + +// DescribeSeverityLevelsWithContext mocks base method +func (m *MockSupportAPI) DescribeSeverityLevelsWithContext(arg0 context.Context, arg1 *support.DescribeSeverityLevelsInput, arg2 ...request.Option) (*support.DescribeSeverityLevelsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeSeverityLevelsWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeSeverityLevelsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeSeverityLevelsWithContext indicates an expected call of DescribeSeverityLevelsWithContext +func (mr *MockSupportAPIMockRecorder) DescribeSeverityLevelsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSeverityLevelsWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeSeverityLevelsWithContext), varargs...) +} + +// DescribeTrustedAdvisorCheckRefreshStatuses mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckRefreshStatuses(arg0 *support.DescribeTrustedAdvisorCheckRefreshStatusesInput) (*support.DescribeTrustedAdvisorCheckRefreshStatusesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckRefreshStatuses", arg0) + ret0, _ := ret[0].(*support.DescribeTrustedAdvisorCheckRefreshStatusesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckRefreshStatuses indicates an expected call of DescribeTrustedAdvisorCheckRefreshStatuses +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckRefreshStatuses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckRefreshStatuses", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckRefreshStatuses), arg0) +} + +// DescribeTrustedAdvisorCheckRefreshStatusesRequest mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckRefreshStatusesRequest(arg0 *support.DescribeTrustedAdvisorCheckRefreshStatusesInput) (*request.Request, *support.DescribeTrustedAdvisorCheckRefreshStatusesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckRefreshStatusesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeTrustedAdvisorCheckRefreshStatusesOutput) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckRefreshStatusesRequest indicates an expected call of DescribeTrustedAdvisorCheckRefreshStatusesRequest +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckRefreshStatusesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckRefreshStatusesRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckRefreshStatusesRequest), arg0) +} + +// DescribeTrustedAdvisorCheckRefreshStatusesWithContext mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckRefreshStatusesWithContext(arg0 context.Context, arg1 *support.DescribeTrustedAdvisorCheckRefreshStatusesInput, arg2 ...request.Option) (*support.DescribeTrustedAdvisorCheckRefreshStatusesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckRefreshStatusesWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeTrustedAdvisorCheckRefreshStatusesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckRefreshStatusesWithContext indicates an expected call of DescribeTrustedAdvisorCheckRefreshStatusesWithContext +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckRefreshStatusesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckRefreshStatusesWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckRefreshStatusesWithContext), varargs...) +} + +// DescribeTrustedAdvisorCheckResult mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckResult(arg0 *support.DescribeTrustedAdvisorCheckResultInput) (*support.DescribeTrustedAdvisorCheckResultOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckResult", arg0) + ret0, _ := ret[0].(*support.DescribeTrustedAdvisorCheckResultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckResult indicates an expected call of DescribeTrustedAdvisorCheckResult +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckResult(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckResult", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckResult), arg0) +} + +// DescribeTrustedAdvisorCheckResultRequest mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckResultRequest(arg0 *support.DescribeTrustedAdvisorCheckResultInput) (*request.Request, *support.DescribeTrustedAdvisorCheckResultOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckResultRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeTrustedAdvisorCheckResultOutput) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckResultRequest indicates an expected call of DescribeTrustedAdvisorCheckResultRequest +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckResultRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckResultRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckResultRequest), arg0) +} + +// DescribeTrustedAdvisorCheckResultWithContext mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckResultWithContext(arg0 context.Context, arg1 *support.DescribeTrustedAdvisorCheckResultInput, arg2 ...request.Option) (*support.DescribeTrustedAdvisorCheckResultOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckResultWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeTrustedAdvisorCheckResultOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckResultWithContext indicates an expected call of DescribeTrustedAdvisorCheckResultWithContext +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckResultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckResultWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckResultWithContext), varargs...) +} + +// DescribeTrustedAdvisorCheckSummaries mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckSummaries(arg0 *support.DescribeTrustedAdvisorCheckSummariesInput) (*support.DescribeTrustedAdvisorCheckSummariesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckSummaries", arg0) + ret0, _ := ret[0].(*support.DescribeTrustedAdvisorCheckSummariesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckSummaries indicates an expected call of DescribeTrustedAdvisorCheckSummaries +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckSummaries(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckSummaries", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckSummaries), arg0) +} + +// DescribeTrustedAdvisorCheckSummariesRequest mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckSummariesRequest(arg0 *support.DescribeTrustedAdvisorCheckSummariesInput) (*request.Request, *support.DescribeTrustedAdvisorCheckSummariesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckSummariesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeTrustedAdvisorCheckSummariesOutput) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckSummariesRequest indicates an expected call of DescribeTrustedAdvisorCheckSummariesRequest +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckSummariesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckSummariesRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckSummariesRequest), arg0) +} + +// DescribeTrustedAdvisorCheckSummariesWithContext mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorCheckSummariesWithContext(arg0 context.Context, arg1 *support.DescribeTrustedAdvisorCheckSummariesInput, arg2 ...request.Option) (*support.DescribeTrustedAdvisorCheckSummariesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorCheckSummariesWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeTrustedAdvisorCheckSummariesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrustedAdvisorCheckSummariesWithContext indicates an expected call of DescribeTrustedAdvisorCheckSummariesWithContext +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorCheckSummariesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorCheckSummariesWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorCheckSummariesWithContext), varargs...) +} + +// DescribeTrustedAdvisorChecks mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorChecks(arg0 *support.DescribeTrustedAdvisorChecksInput) (*support.DescribeTrustedAdvisorChecksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorChecks", arg0) + ret0, _ := ret[0].(*support.DescribeTrustedAdvisorChecksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrustedAdvisorChecks indicates an expected call of DescribeTrustedAdvisorChecks +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorChecks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorChecks", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorChecks), arg0) +} + +// DescribeTrustedAdvisorChecksRequest mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorChecksRequest(arg0 *support.DescribeTrustedAdvisorChecksInput) (*request.Request, *support.DescribeTrustedAdvisorChecksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorChecksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.DescribeTrustedAdvisorChecksOutput) + return ret0, ret1 +} + +// DescribeTrustedAdvisorChecksRequest indicates an expected call of DescribeTrustedAdvisorChecksRequest +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorChecksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorChecksRequest", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorChecksRequest), arg0) +} + +// DescribeTrustedAdvisorChecksWithContext mocks base method +func (m *MockSupportAPI) DescribeTrustedAdvisorChecksWithContext(arg0 context.Context, arg1 *support.DescribeTrustedAdvisorChecksInput, arg2 ...request.Option) (*support.DescribeTrustedAdvisorChecksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrustedAdvisorChecksWithContext", varargs...) + ret0, _ := ret[0].(*support.DescribeTrustedAdvisorChecksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrustedAdvisorChecksWithContext indicates an expected call of DescribeTrustedAdvisorChecksWithContext +func (mr *MockSupportAPIMockRecorder) DescribeTrustedAdvisorChecksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustedAdvisorChecksWithContext", reflect.TypeOf((*MockSupportAPI)(nil).DescribeTrustedAdvisorChecksWithContext), varargs...) +} + +// RefreshTrustedAdvisorCheck mocks base method +func (m *MockSupportAPI) RefreshTrustedAdvisorCheck(arg0 *support.RefreshTrustedAdvisorCheckInput) (*support.RefreshTrustedAdvisorCheckOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RefreshTrustedAdvisorCheck", arg0) + ret0, _ := ret[0].(*support.RefreshTrustedAdvisorCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RefreshTrustedAdvisorCheck indicates an expected call of RefreshTrustedAdvisorCheck +func (mr *MockSupportAPIMockRecorder) RefreshTrustedAdvisorCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshTrustedAdvisorCheck", reflect.TypeOf((*MockSupportAPI)(nil).RefreshTrustedAdvisorCheck), arg0) +} + +// RefreshTrustedAdvisorCheckRequest mocks base method +func (m *MockSupportAPI) RefreshTrustedAdvisorCheckRequest(arg0 *support.RefreshTrustedAdvisorCheckInput) (*request.Request, *support.RefreshTrustedAdvisorCheckOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RefreshTrustedAdvisorCheckRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.RefreshTrustedAdvisorCheckOutput) + return ret0, ret1 +} + +// RefreshTrustedAdvisorCheckRequest indicates an expected call of RefreshTrustedAdvisorCheckRequest +func (mr *MockSupportAPIMockRecorder) RefreshTrustedAdvisorCheckRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshTrustedAdvisorCheckRequest", reflect.TypeOf((*MockSupportAPI)(nil).RefreshTrustedAdvisorCheckRequest), arg0) +} + +// RefreshTrustedAdvisorCheckWithContext mocks base method +func (m *MockSupportAPI) RefreshTrustedAdvisorCheckWithContext(arg0 context.Context, arg1 *support.RefreshTrustedAdvisorCheckInput, arg2 ...request.Option) (*support.RefreshTrustedAdvisorCheckOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RefreshTrustedAdvisorCheckWithContext", varargs...) + ret0, _ := ret[0].(*support.RefreshTrustedAdvisorCheckOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RefreshTrustedAdvisorCheckWithContext indicates an expected call of RefreshTrustedAdvisorCheckWithContext +func (mr *MockSupportAPIMockRecorder) RefreshTrustedAdvisorCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshTrustedAdvisorCheckWithContext", reflect.TypeOf((*MockSupportAPI)(nil).RefreshTrustedAdvisorCheckWithContext), varargs...) +} + +// ResolveCase mocks base method +func (m *MockSupportAPI) ResolveCase(arg0 *support.ResolveCaseInput) (*support.ResolveCaseOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResolveCase", arg0) + ret0, _ := ret[0].(*support.ResolveCaseOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResolveCase indicates an expected call of ResolveCase +func (mr *MockSupportAPIMockRecorder) ResolveCase(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveCase", reflect.TypeOf((*MockSupportAPI)(nil).ResolveCase), arg0) +} + +// ResolveCaseRequest mocks base method +func (m *MockSupportAPI) ResolveCaseRequest(arg0 *support.ResolveCaseInput) (*request.Request, *support.ResolveCaseOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResolveCaseRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*support.ResolveCaseOutput) + return ret0, ret1 +} + +// ResolveCaseRequest indicates an expected call of ResolveCaseRequest +func (mr *MockSupportAPIMockRecorder) ResolveCaseRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveCaseRequest", reflect.TypeOf((*MockSupportAPI)(nil).ResolveCaseRequest), arg0) +} + +// ResolveCaseWithContext mocks base method +func (m *MockSupportAPI) ResolveCaseWithContext(arg0 context.Context, arg1 *support.ResolveCaseInput, arg2 ...request.Option) (*support.ResolveCaseOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResolveCaseWithContext", varargs...) + ret0, _ := ret[0].(*support.ResolveCaseOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResolveCaseWithContext indicates an expected call of ResolveCaseWithContext +func (mr *MockSupportAPIMockRecorder) ResolveCaseWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveCaseWithContext", reflect.TypeOf((*MockSupportAPI)(nil).ResolveCaseWithContext), varargs...) +} diff --git a/sourcehawk.yml b/sourcehawk.yml new file mode 100644 index 0000000..a228e9b --- /dev/null +++ b/sourcehawk.yml @@ -0,0 +1,4 @@ + +config-locations: + - https://raw.githubusercontent.com/optum/.github/main/sourcehawk.yml + diff --git a/test/data/comments.yaml b/test/data/comments.yaml new file mode 100644 index 0000000..5db0273 --- /dev/null +++ b/test/data/comments.yaml @@ -0,0 +1,22 @@ +- accountid: "111111111111" + ta-findings: + - SECURITY-IAM_Use: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM" + config-findings: + - IAM_POLICY_BLACKLISTED_CHECK: "**EXCEPTION:** Removed the AdminstratorAccess policy since the default AWS_*_Admins uses the policy. Future enhancement would be to create a Custom Rule that no other Role can use the AdmnistratorAccess policy besides the AWS_*_Admins" + inspector-findings: + - CIS_Operating_System_Security_Configuration_Benchmarks-1.0: "**EXCEPTION:** Description here" + health-findings: + - AWS_RDS_SECURITY_NOTIFICATION: "**EXCEPTION:** Description here" + reflect-iam-findings: + - arn:aws:iam::111111111111:role/eks-worker-dig-green-dev: "**EXCEPTION:** Ignore AccessDenied error. This role doesn't require s3.amazonaws.com/HeadObject access for its functionality" +- accountid: "222222222222" + ta-findings: + - SECURITY-IAM_Use: "**EXCEPTION:** We use Federation and IAM roles to manage resources in AWS . No users/groups created in IAM" + - FAULT_TOLERANCE-Amazon_EBS_Snapshots: "**EXCEPTION:** We do not persist any critical data on EC2 attached EBS. Data present in these disks are ephemeral in nature" + config-findings: + - ATTACHED_INTERNET_GATEWAY_CHECK: "**EXCEPTION:** Flags VPCs that have an Internet Gateway attached, Most of our VPC requires IGW enabled in Public subnets as they are web application open to Internet. Better RULE would be to check VPC with all of its SUBNET open to IGW" + - IAM_POLICY_BLACKLISTED_CHECK: "**EXCEPTION:** Removed the AdminstratorAccess policy since the default AWS_*_Admins uses the policy. Future enhancement would be to create a Custom Rule that no other Role can use the AdmnistratorAccess policy besides the AWS_*_Admins" +- accountid: "012345678910" + ecr-findings: + - 012345678910.dkr.ecr.us-east-1.amazonaws.com/app/web-server:prod-canary: "EXCEPTION Patch will applied this weekend" + - ALL:v1.2.0: "EXCEPTION Patch is coming tomorrow" diff --git a/test/data/inspector_report_test.html b/test/data/inspector_report_test.html new file mode 100755 index 0000000..b47a6d8 --- /dev/null +++ b/test/data/inspector_report_test.html @@ -0,0 +1,60 @@ + + + + + Amazon Inspector - Assessment Report + + +
+
+
Amazon Inspector - Assessment Report
+
Full Report
Report generated on 2019-07-30 at 18:47:14 UTC
+
Assessment Template: k8s_weekly_scan
+
Assessment Run start: 2019-07-27 at 06:00:06 UTC
+
Assessment Run end: 2019-07-27 at 07:07:02 UTC
+
+
+
Section 1: Executive Summary
+
This is an Inspector assessment report for an assessment started on 2019-07-27 06:00:06 UTC for assessment template 'k8s_weekly_scan'. The assessment target included 29 instances, and was tested against 4 Rules Packages.
+
+
The assessment target is defined using the following EC2 tags
+ + +
Key Value
aws_inspector true
+
The following Rules Packages were assessed. A total of 2955 findings were created, with the following distribution by severity:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Rules Package High Medium Low Informational
CIS Operating System Security Configuration Benchmarks-1.0 2581 0 0 232
Common Vulnerabilities and Exposures-1.1 29 46 0 0
Runtime Behavior Analysis-1.0 0 0 23 44
Security Best Practices-1.0 0 0 0 0
+
+ + \ No newline at end of file