From e2f6c149c6a5b4333ea779fd9715e1fdb29491ca Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Tue, 24 Jun 2025 02:29:13 +0200
Subject: [PATCH 01/12] add support for nested secrets manager keys

---
 README.md                       | 43 +++++++++++++++++++++++++++++++++
 go.mod                          |  3 +++
 go.sum                          |  7 ++++++
 pkg/secrets/aws/secrets.go      | 43 +++++++++++++++++++++++++--------
 pkg/secrets/aws/secrets_test.go | 27 +++++++++++++++++++++
 5 files changed, 113 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 52ba7b0..b5bbd41 100644
--- a/README.md
+++ b/README.md
@@ -32,6 +32,9 @@ Summary:
 User can put AWS secret ARN as environment variable value. The `secrets-init` will resolve any environment value, using specified ARN, to referenced secret value.
 
 If the secret is saved as a Key/Value pair, all the keys are applied to as environment variables and passed. The environment variable passed is ignored unless it is inside the key/value pair.
+
+#### Simple Key/Value Secrets
+
 ```sh
 # environment variable passed to `secrets-init`
 MY_DB_PASSWORD=arn:aws:secretsmanager:$AWS_REGION:$AWS_ACCOUNT_ID:secret:mydbpassword-cdma3
@@ -40,6 +43,46 @@ MY_DB_PASSWORD=arn:aws:secretsmanager:$AWS_REGION:$AWS_ACCOUNT_ID:secret:mydbpas
 MY_DB_PASSWORD=very-secret-password
 ```
 
+#### JSON Secrets with Nested Key Extraction
+
+For JSON secrets, you can extract specific nested values using the `$` syntax followed by [gjson](https://github.com/tidwall/gjson) path expressions:
+
+```sh
+# Extract a top-level key from JSON
+MY_DB_PASSWORD=arn:aws:secretsmanager:$AWS_REGION:$AWS_ACCOUNT_ID:secret:mydbpassword-cdma3$password
+
+# Extract a nested key from JSON
+MY_REDIS_PASSWORD=arn:aws:secretsmanager:$AWS_REGION:$AWS_ACCOUNT_ID:secret:mydbpassword-cdma3$redis.password
+
+# Extract from array elements
+MY_API_KEY=arn:aws:secretsmanager:$AWS_REGION:$AWS_ACCOUNT_ID:secret:apikeys-cdma3$keys.0.value
+
+# If the nested key doesn't exist, the original ARN is preserved
+MY_INEXISTENT_KEY=arn:aws:secretsmanager:$AWS_REGION:$AWS_ACCOUNT_ID:secret:mydbpassword-cdma3$inexistent.key
+```
+
+**Example JSON Secret:**
+```json
+{
+  "password": "secret-password",
+  "redis": {
+    "password": "secret-redis-password"
+  },
+  "keys": [
+    {"value": "api-key-1"},
+    {"value": "api-key-2"}
+  ]
+}
+```
+
+**Resulting Environment Variables:**
+```sh
+MY_DB_PASSWORD=secret-password
+MY_REDIS_PASSWORD=secret-redis-password
+MY_API_KEY=api-key-1
+MY_INEXISTENT_KEY=arn:aws:secretsmanager:us-east-1:123456789012:secret:mydbpassword-cdma3$inexistent.key
+```
+
 ### Integration with AWS Systems Manager Parameter Store
 
 It is possible to use AWS Systems Manager Parameter Store to store application parameters and secrets.
diff --git a/go.mod b/go.mod
index 03e25b2..fe1c93d 100644
--- a/go.mod
+++ b/go.mod
@@ -28,6 +28,9 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/stretchr/objx v0.5.0 // indirect
+	github.com/tidwall/gjson v1.18.0 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	go.opencensus.io v0.23.0 // indirect
 	golang.org/x/net v0.15.0 // indirect
diff --git a/go.sum b/go.sum
index f5de4ec..126c917 100644
--- a/go.sum
+++ b/go.sum
@@ -81,6 +81,13 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
+github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/urfave/cli/v2 v2.23.0 h1:pkly7gKIeYv3olPAeNajNpLjeJrmTPYCoZWaV+2VfvE=
 github.com/urfave/cli/v2 v2.23.0/go.mod h1:1CNUng3PtjQMtRzJO4FMXBQvkGtuYRxxiR9xMa7jMwI=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
diff --git a/pkg/secrets/aws/secrets.go b/pkg/secrets/aws/secrets.go
index 28cb6c6..2c3782f 100644
--- a/pkg/secrets/aws/secrets.go
+++ b/pkg/secrets/aws/secrets.go
@@ -14,6 +14,8 @@ import (
 	"github.com/aws/aws-sdk-go/service/ssm"
 	"github.com/aws/aws-sdk-go/service/ssm/ssmiface"
 	"github.com/pkg/errors" //nolint:gci
+
+	"github.com/tidwall/gjson"
 )
 
 const (
@@ -53,24 +55,45 @@ func (sp *SecretsProvider) ResolveSecrets(_ context.Context, vars []string) ([]s
 		kv := strings.Split(env, "=")
 		key, value := kv[0], kv[1]
 		if strings.HasPrefix(value, "arn:aws:secretsmanager") || strings.HasPrefix(value, "arn:aws-cn:secretsmanager") {
+			sk := strings.Split(value, "$")
+			value = sk[0]
+			nestedKey := ""
+
+			if len(sk) > 1 {
+				nestedKey = sk[1]
+			}
+
 			// get secret value
 			secret, err := sp.sm.GetSecretValue(&secretsmanager.GetSecretValueInput{SecretId: &value})
 			if err != nil {
 				return vars, errors.Wrap(err, "failed to get secret from AWS Secrets Manager")
 			}
+
 			if IsJSON(secret.SecretString) {
-				var keyValueSecret map[string]string
-				err = json.Unmarshal([]byte(*secret.SecretString), &keyValueSecret)
-				if err != nil {
-					return vars, errors.Wrap(err, "failed to decode key/value secret")
-				}
-				for key, value := range keyValueSecret {
-					e := key + "=" + value
-					envs = append(envs, e)
+
+				if nestedKey != "" {
+					jsonValue := gjson.Get(*secret.SecretString, nestedKey)
+					if jsonValue.Exists() {
+						env = key + "=" + jsonValue.String()
+					}
+				} else {
+					var keyValueSecret map[string]string
+					err = json.Unmarshal([]byte(*secret.SecretString), &keyValueSecret)
+					if err != nil {
+						return vars, errors.Wrap(err, "failed to decode key/value secret")
+					}
+					for key, value := range keyValueSecret {
+						e := key + "=" + value
+						envs = append(envs, e)
+					}
+					continue // We continue to not add this ENV variable but only the environment variables that exists in the JSON
+
 				}
-				continue // We continue to not add this ENV variable but only the environment variables that exists in the JSON
+
+			} else {
+				env = key + "=" + *secret.SecretString
 			}
-			env = key + "=" + *secret.SecretString
+
 		} else if (strings.HasPrefix(value, "arn:aws:ssm") || strings.HasPrefix(value, "arn:aws-cn:ssm")) && strings.Contains(value, ":parameter/") {
 			tokens := strings.Split(value, ":")
 			// valid parameter ARN arn:aws:ssm:REGION:ACCOUNT:parameter/PATH
diff --git a/pkg/secrets/aws/secrets_test.go b/pkg/secrets/aws/secrets_test.go
index 1a60bd3..0a56d57 100644
--- a/pkg/secrets/aws/secrets_test.go
+++ b/pkg/secrets/aws/secrets_test.go
@@ -92,6 +92,33 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 				return &sp
 			},
 		},
+		{
+			name: "get secret from from Secrets Manager json with nested key",
+			vars: []string{
+				"test-secret-1=arn:aws:secretsmanager:12345678-json-nested$password",
+				"test-secret-2=arn:aws:secretsmanager:12345678-json-nested$redis.password",
+				"test-secret-3=arn:aws:secretsmanager:12345678-json-nested$inexistent",
+			},
+			want: []string{
+				"test-secret-1=secret-password",
+				"test-secret-2=secret-redis-password",
+				"test-secret-3=arn:aws:secretsmanager:12345678-json-nested$inexistent",
+			},
+			mockServiceProvider: func(mockSM *mocks.SecretsManagerAPI, mockSSM *mocks.SSMAPI) secrets.Provider {
+				sp := SecretsProvider{sm: mockSM, ssm: mockSSM}
+				vars := map[string]string{
+					"arn:aws:secretsmanager:12345678-json-nested": "{\n  \"TEST_1\": \"test-secret-value-1\",\n  \"TEST_2\": \"test-secret-value-2\"\n, \"password\": \"secret-password\", \"redis\": {\"password\": \"secret-redis-password\"}\n}",
+				}
+				for n, v := range vars {
+					name := n
+					value := v
+					valueInput := secretsmanager.GetSecretValueInput{SecretId: &name}
+					valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &value}
+					mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+				}
+				return &sp
+			},
+		},
 		{
 			name: "no secrets",
 			vars: []string{

From e5316ae30544a7be599b17b9ba37e6910ce24f70 Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Tue, 24 Jun 2025 02:31:36 +0200
Subject: [PATCH 02/12] add more test cases

---
 pkg/secrets/aws/secrets_test.go | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/pkg/secrets/aws/secrets_test.go b/pkg/secrets/aws/secrets_test.go
index 0a56d57..a3527c1 100644
--- a/pkg/secrets/aws/secrets_test.go
+++ b/pkg/secrets/aws/secrets_test.go
@@ -119,6 +119,35 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 				return &sp
 			},
 		},
+		{
+			name: "get secret from Secrets Manager json with array elements",
+			vars: []string{
+				"api-key-1=arn:aws:secretsmanager:12345678-json-array$keys.0.value",
+				"api-key-2=arn:aws:secretsmanager:12345678-json-array$keys.1.value",
+				"api-key-3=arn:aws:secretsmanager:12345678-json-array$keys.2.value",
+				"non-existent=arn:aws:secretsmanager:12345678-json-array$keys.5.value",
+			},
+			want: []string{
+				"api-key-1=api-key-1-value",
+				"api-key-2=api-key-2-value",
+				"api-key-3=api-key-3-value",
+				"non-existent=arn:aws:secretsmanager:12345678-json-array$keys.5.value",
+			},
+			mockServiceProvider: func(mockSM *mocks.SecretsManagerAPI, mockSSM *mocks.SSMAPI) secrets.Provider {
+				sp := SecretsProvider{sm: mockSM, ssm: mockSSM}
+				vars := map[string]string{
+					"arn:aws:secretsmanager:12345678-json-array": "{\n  \"keys\": [\n    {\"value\": \"api-key-1-value\"},\n    {\"value\": \"api-key-2-value\"},\n    {\"value\": \"api-key-3-value\"}\n  ]\n}",
+				}
+				for n, v := range vars {
+					name := n
+					value := v
+					valueInput := secretsmanager.GetSecretValueInput{SecretId: &name}
+					valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &value}
+					mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+				}
+				return &sp
+			},
+		},
 		{
 			name: "no secrets",
 			vars: []string{

From 61ec00654c0fdca9880301d0976a7f5aee995d4a Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Tue, 24 Jun 2025 14:04:07 +0200
Subject: [PATCH 03/12] use cut instead, such that it only cares about first
 occurence of seperator

---
 pkg/secrets/aws/secrets.go | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/pkg/secrets/aws/secrets.go b/pkg/secrets/aws/secrets.go
index 2c3782f..527bbc4 100644
--- a/pkg/secrets/aws/secrets.go
+++ b/pkg/secrets/aws/secrets.go
@@ -55,13 +55,7 @@ func (sp *SecretsProvider) ResolveSecrets(_ context.Context, vars []string) ([]s
 		kv := strings.Split(env, "=")
 		key, value := kv[0], kv[1]
 		if strings.HasPrefix(value, "arn:aws:secretsmanager") || strings.HasPrefix(value, "arn:aws-cn:secretsmanager") {
-			sk := strings.Split(value, "$")
-			value = sk[0]
-			nestedKey := ""
-
-			if len(sk) > 1 {
-				nestedKey = sk[1]
-			}
+			value, nestedKey, _ := strings.Cut(value, "$")
 
 			// get secret value
 			secret, err := sp.sm.GetSecretValue(&secretsmanager.GetSecretValueInput{SecretId: &value})

From aed9b2b836cb601a23fa88e888a77c743448b138 Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Tue, 24 Jun 2025 14:06:55 +0200
Subject: [PATCH 04/12] add test and update readme

---
 README.md                       |  2 ++
 pkg/secrets/aws/secrets_test.go | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/README.md b/README.md
index b5bbd41..3c7e39f 100644
--- a/README.md
+++ b/README.md
@@ -47,6 +47,8 @@ MY_DB_PASSWORD=very-secret-password
 
 For JSON secrets, you can extract specific nested values using the `$` syntax followed by [gjson](https://github.com/tidwall/gjson) path expressions:
 
+> **Note:** If your secret name contains multiple `$` characters, only the first `$` is used to split the secret ARN from the nested key path. For example, `arn:aws:secretsmanager:mysecret$level$key` will extract the key `level$key` from the secret named `arn:aws:secretsmanager:mysecret`.
+
 ```sh
 # Extract a top-level key from JSON
 MY_DB_PASSWORD=arn:aws:secretsmanager:$AWS_REGION:$AWS_ACCOUNT_ID:secret:mydbpassword-cdma3$password
diff --git a/pkg/secrets/aws/secrets_test.go b/pkg/secrets/aws/secrets_test.go
index a3527c1..98e5f13 100644
--- a/pkg/secrets/aws/secrets_test.go
+++ b/pkg/secrets/aws/secrets_test.go
@@ -220,6 +220,24 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 				return &sp
 			},
 		},
+		{
+			name: "only first occurrence of separator is used",
+			vars: []string{
+				"test-secret=arn:aws:secretsmanager:multi$level$key",
+			},
+			want: []string{
+				"test-secret=the-value-for-level$key",
+			},
+			mockServiceProvider: func(mockSM *mocks.SecretsManagerAPI, mockSSM *mocks.SSMAPI) secrets.Provider {
+				sp := SecretsProvider{sm: mockSM, ssm: mockSSM}
+				secretName := "arn:aws:secretsmanager:multi"
+				secretValue := "{\"level$key\": \"the-value-for-level$key\"}"
+				valueInput := secretsmanager.GetSecretValueInput{SecretId: &secretName}
+				valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &secretValue}
+				mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+				return &sp
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

From c4db94710e15213285283b5def156f22ac184953 Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Wed, 25 Jun 2025 10:42:35 +0200
Subject: [PATCH 05/12] remove empty line

---
 pkg/secrets/aws/secrets.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pkg/secrets/aws/secrets.go b/pkg/secrets/aws/secrets.go
index 527bbc4..77df448 100644
--- a/pkg/secrets/aws/secrets.go
+++ b/pkg/secrets/aws/secrets.go
@@ -14,7 +14,6 @@ import (
 	"github.com/aws/aws-sdk-go/service/ssm"
 	"github.com/aws/aws-sdk-go/service/ssm/ssmiface"
 	"github.com/pkg/errors" //nolint:gci
-
 	"github.com/tidwall/gjson"
 )
 

From e7ffb5f982e7f3701d72e26d4fc8de2156469072 Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Wed, 25 Jun 2025 10:50:36 +0200
Subject: [PATCH 06/12] remove empty line

---
 pkg/secrets/aws/secrets_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/secrets/aws/secrets_test.go b/pkg/secrets/aws/secrets_test.go
index 98e5f13..b452d0f 100644
--- a/pkg/secrets/aws/secrets_test.go
+++ b/pkg/secrets/aws/secrets_test.go
@@ -136,7 +136,7 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 			mockServiceProvider: func(mockSM *mocks.SecretsManagerAPI, mockSSM *mocks.SSMAPI) secrets.Provider {
 				sp := SecretsProvider{sm: mockSM, ssm: mockSSM}
 				vars := map[string]string{
-					"arn:aws:secretsmanager:12345678-json-array": "{\n  \"keys\": [\n    {\"value\": \"api-key-1-value\"},\n    {\"value\": \"api-key-2-value\"},\n    {\"value\": \"api-key-3-value\"}\n  ]\n}",
+					"arn:aws:secretsmanager:12345678-json-array": "{\n  \"keys\": [\n {\"value\": \"api-key-1-value\"},\n    {\"value\": \"api-key-2-value\"},\n    {\"value\": \"api-key-3-value\"}\n  ]\n}",
 				}
 				for n, v := range vars {
 					name := n

From 5263a5d4395dd7020a86282470ba237911d1d5b3 Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Wed, 25 Jun 2025 11:51:30 +0200
Subject: [PATCH 07/12] fix lint

---
 pkg/secrets/aws/secrets.go | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/pkg/secrets/aws/secrets.go b/pkg/secrets/aws/secrets.go
index 77df448..3184376 100644
--- a/pkg/secrets/aws/secrets.go
+++ b/pkg/secrets/aws/secrets.go
@@ -14,6 +14,7 @@ import (
 	"github.com/aws/aws-sdk-go/service/ssm"
 	"github.com/aws/aws-sdk-go/service/ssm/ssmiface"
 	"github.com/pkg/errors" //nolint:gci
+
 	"github.com/tidwall/gjson"
 )
 
@@ -54,16 +55,15 @@ func (sp *SecretsProvider) ResolveSecrets(_ context.Context, vars []string) ([]s
 		kv := strings.Split(env, "=")
 		key, value := kv[0], kv[1]
 		if strings.HasPrefix(value, "arn:aws:secretsmanager") || strings.HasPrefix(value, "arn:aws-cn:secretsmanager") {
-			value, nestedKey, _ := strings.Cut(value, "$")
+			secretKey, nestedKey, _ := strings.Cut(value, "$")
 
 			// get secret value
-			secret, err := sp.sm.GetSecretValue(&secretsmanager.GetSecretValueInput{SecretId: &value})
+			secret, err := sp.sm.GetSecretValue(&secretsmanager.GetSecretValueInput{SecretId: &secretKey})
 			if err != nil {
 				return vars, errors.Wrap(err, "failed to get secret from AWS Secrets Manager")
 			}
 
 			if IsJSON(secret.SecretString) {
-
 				if nestedKey != "" {
 					jsonValue := gjson.Get(*secret.SecretString, nestedKey)
 					if jsonValue.Exists() {
@@ -80,13 +80,10 @@ func (sp *SecretsProvider) ResolveSecrets(_ context.Context, vars []string) ([]s
 						envs = append(envs, e)
 					}
 					continue // We continue to not add this ENV variable but only the environment variables that exists in the JSON
-
 				}
-
 			} else {
 				env = key + "=" + *secret.SecretString
 			}
-
 		} else if (strings.HasPrefix(value, "arn:aws:ssm") || strings.HasPrefix(value, "arn:aws-cn:ssm")) && strings.Contains(value, ":parameter/") {
 			tokens := strings.Split(value, ":")
 			// valid parameter ARN arn:aws:ssm:REGION:ACCOUNT:parameter/PATH

From e99342de5f2cea68fbec6ab1e2028b0a2cd9140f Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Wed, 25 Jun 2025 12:45:26 +0200
Subject: [PATCH 08/12] fix lint

---
 main.go                         | 2 +-
 pkg/secrets/google/interface.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/main.go b/main.go
index 57cdbef..76d6714 100644
--- a/main.go
+++ b/main.go
@@ -17,7 +17,7 @@ import (
 
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
-	"github.com/urfave/cli/v2"
+	cli "github.com/urfave/cli/v2"
 	"golang.org/x/sys/unix" //nolint:gci
 )
 
diff --git a/pkg/secrets/google/interface.go b/pkg/secrets/google/interface.go
index 6e40f36..97d9a5b 100644
--- a/pkg/secrets/google/interface.go
+++ b/pkg/secrets/google/interface.go
@@ -3,7 +3,7 @@ package google
 import (
 	"context"
 
-	"github.com/googleapis/gax-go/v2"
+	gax "github.com/googleapis/gax-go/v2"
 	secretspb "google.golang.org/genproto/googleapis/cloud/secretmanager/v1"
 )
 

From 95438841ba4e4f64018941210dc712ec32c6f1c3 Mon Sep 17 00:00:00 2001
From: Husayn Arrah <husayn@paystack.com>
Date: Wed, 25 Jun 2025 13:00:14 +0200
Subject: [PATCH 09/12] update checkout action

---
 .github/workflows/docker-release.yaml | 2 +-
 .github/workflows/github-release.yaml | 2 +-
 .github/workflows/test.yaml           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/docker-release.yaml b/.github/workflows/docker-release.yaml
index efc6a62..1b53366 100644
--- a/.github/workflows/docker-release.yaml
+++ b/.github/workflows/docker-release.yaml
@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2
diff --git a/.github/workflows/github-release.yaml b/.github/workflows/github-release.yaml
index 7f91c7a..286617b 100644
--- a/.github/workflows/github-release.yaml
+++ b/.github/workflows/github-release.yaml
@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Install Go
         uses: actions/setup-go@v3
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index 0128692..0a8dc82 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Install Go
         uses: actions/setup-go@v3

From dc0e00c187c11b230e2c58de20031ec4767723c3 Mon Sep 17 00:00:00 2001
From: ibrahimlawal <ibrahim@paystack.com>
Date: Fri, 17 Jul 2026 14:06:06 +0100
Subject: [PATCH 10/12] PSR-41: modernize secrets-init dependencies

---
 .github/workflows/docker-release.yaml |    31 +-
 .github/workflows/github-release.yaml |    18 +-
 .github/workflows/test.yaml           |    14 +-
 .golangci.yaml                        |   180 +-
 .mockery.yml                          |    20 +
 Dockerfile                            |    17 +-
 Makefile                              |    33 +-
 go.mod                                |    91 +-
 go.sum                                |   318 +-
 main.go                               |    51 +-
 mocks/GoogleSecretsManagerAPI.go      |   130 +-
 mocks/SSMAPI.go                       | 12235 +-----------------------
 mocks/SecretsManagerAPI.go            |  1846 +---
 pkg/secrets/aws/secrets.go            |   215 +-
 pkg/secrets/aws/secrets_test.go       |    65 +-
 pkg/secrets/google/interface.go       |     2 +-
 pkg/secrets/google/secrets.go         |     8 +-
 pkg/secrets/google/secrets_test.go    |     6 +-
 18 files changed, 835 insertions(+), 14445 deletions(-)
 create mode 100644 .mockery.yml

diff --git a/.github/workflows/docker-release.yaml b/.github/workflows/docker-release.yaml
index 1b53366..0bde54e 100644
--- a/.github/workflows/docker-release.yaml
+++ b/.github/workflows/docker-release.yaml
@@ -9,30 +9,34 @@ on:
       - 'docs/**'
       - '*.md'
 
+permissions:
+  contents: read
+  packages: write
+
 jobs:
   release:
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v4
 
       - name: Set up Docker buildx
         id: buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v4
 
       - name: Login to Docker Registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v4
         with:
           registry: ${{ secrets.DOCKER_REGISTRY }}
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v4
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -46,23 +50,20 @@ jobs:
         env:
           DOCKER_REPOSITORY: ${{ secrets.DOCKER_REPOSITORY }}
         run: |
-          name=${DOCKER_REPOSITORY}
-          if [ -z "$name" ]; then
-          name=${{ github.repository }}
-          fi
-          echo ::set-output name=name::${name}
-          echo ::debug::docker image name ${name}
+          name="${DOCKER_REPOSITORY:-${GITHUB_REPOSITORY}}"
+          echo "name=${name}" >> "$GITHUB_OUTPUT"
+          echo "::debug::docker image name ${name}"
 
       - name: Decide on tag
         id: tagger
         run: |
-          tag=$(echo "${{ github.ref }}" | sed -e 's/^refs\/heads\///g' -e 's/^refs\/tags\///g' -e 's/^refs\/pull\///g' -e 's/\/merge$//g' | sed -e 's/master/latest/g')
-          echo "::set-output name=tag::${tag}"
+          tag=$(echo "${GITHUB_REF}" | sed -e 's/^refs\/heads\///g' -e 's/^refs\/tags\///g' -e 's/^refs\/pull\///g' -e 's/\/merge$//g' | sed -e 's/master/latest/g')
+          echo "tag=${tag}" >> "$GITHUB_OUTPUT"
           echo "::debug::docker image tag ${tag}"
 
       - name: Build and push Docker image
         id: build-push
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v7
         with:
           build-args: VERSION=${{ steps.tagger.outputs.tag }}
           platforms: linux/amd64,linux/arm64
@@ -74,4 +75,4 @@ jobs:
           push: true
 
       - name: Image digest
-        run: echo "${{ steps.build-push.outputs.digest }}"
\ No newline at end of file
+        run: echo "${{ steps.build-push.outputs.digest }}"
diff --git a/.github/workflows/github-release.yaml b/.github/workflows/github-release.yaml
index 286617b..b996453 100644
--- a/.github/workflows/github-release.yaml
+++ b/.github/workflows/github-release.yaml
@@ -9,32 +9,36 @@ on:
       - 'docs/**'
       - '*.md'
 
+permissions:
+  contents: write
+
 jobs:
   release:
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Install Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v7
         with:
-          go-version: '>=1.21.0'
+          go-version: '1.26.5'
+          cache: true
 
       - name: Cross-Platform build
         run: |
-          make platfrom-build
+          make platform-build
 
       - name: Build Changelog
         id: build_changelog
-        uses: mikepenz/release-changelog-builder-action@v3
+        uses: mikepenz/release-changelog-builder-action@v6
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Create Release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v3
         with:
-          body: ${{steps.github_release.outputs.changelog}}
+          body: ${{ steps.build_changelog.outputs.changelog }}
           files: |
             .bin/*
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index 0a8dc82..63569a1 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -1,4 +1,5 @@
 name: test
+
 on:
   push:
     branches:
@@ -14,18 +15,23 @@ on:
 env:
   GOPROXY: https://proxy.golang.org
   CGO_ENABLED: 0
+
+permissions:
+  contents: read
+
 jobs:
   test:
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Install Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v7
         with:
-          go-version: '>=1.21.0'
+          go-version: '1.26.5'
+          cache: true
 
       - name: Lint
         run: |
@@ -33,4 +39,4 @@ jobs:
 
       - name: Test
         run: |
-          make test
\ No newline at end of file
+          make test
diff --git a/.golangci.yaml b/.golangci.yaml
index 8a8fd99..d810d35 100644
--- a/.golangci.yaml
+++ b/.golangci.yaml
@@ -1,144 +1,130 @@
+version: "2"
 run:
-  # which dirs to skip
-  skip-dirs:
-    - mocks
-  # Timeout for analysis, e.g. 30s, 5m.
-  # Default: 1m
-  timeout: 5m
-  # Exit code when at least one issue was found.
-  # Default: 1
   issues-exit-code: 2
-  # Include test files or not.
-  # Default: true
   tests: false
-
-linters-settings:
-  govet:
-    check-shadowing: true
-  gocyclo:
-    min-complexity: 15
-  maligned:
-    suggest-new: true
-  dupl:
-    threshold: 100
-  goconst:
-    min-len: 2
-    min-occurrences: 2
-  misspell:
-    locale: US
-    ignore-words:
-      - "cancelled"
-  goimports:
-    local-prefixes: github.com/golangci/golangci-lint
-  gocritic:
-    enabled-tags:
-      - diagnostic
-      - experimental
-      - opinionated
-      - performance
-      - style
-    disabled-checks:
-      - dupImport # https://github.com/go-critic/go-critic/issues/845
-      - ifElseChain
-      - octalLiteral
-      - rangeValCopy
-      - unnamedResult
-      - whyNoLint
-      - wrapperFunc
-  funlen:
-    lines: 105
-    statements: 50
-
 linters:
-  # please, do not use `enable-all`: it's deprecated and will be removed soon.
-  # inverted configuration with `enable-all` and `disable` is not scalable during updates of golangci-lint
-  disable-all: true
+  default: none
   enable:
     - asciicheck
     - bidichk
     - bodyclose
-    # - containedctx
-    # - contextcheck disabled because of generics
-    - dupword
     - decorder
-    # - depguard
     - dogsled
     - dupl
+    - dupword
     - durationcheck
+    - err113
     - errcheck
     - errchkjson
     - errname
     - errorlint
     - exhaustive
-    # - exhaustivestruct TODO: check how to fix it
-    - exportloopref
-    # - forbidigo TODO: configure forbidden code patterns
-    # - forcetypeassert
     - funlen
-    - gci
-    # - gochecknoglobals TODO: remove globals from code
-    # - gochecknoinits TODO: remove main.init
     - gocognit
     - goconst
     - gocritic
     - gocyclo
-    #    - godox
-    - goerr113
-    - gofmt
-    - goimports
-    - gomnd
-    # - gomoddirectives
+    - goprintffuncname
     - gosec
-    - gosimple
     - govet
-    - goprintffuncname
     - grouper
     - importas
-    # - ireturn TODO: not sure if it is a good linter
     - ineffassign
     - interfacebloat
     - loggercheck
     - maintidx
     - makezero
     - misspell
+    - mnd
     - nakedret
-    # - nestif
     - nilerr
     - nilnil
-    # - noctx
     - nolintlint
     - prealloc
     - predeclared
     - promlinter
     - reassign
     - revive
-    # - rowserrcheck disabled because of generics
-    # - staticcheck doesn't work with go1.19
-    # - structcheck disabled because of generics
-    - stylecheck
-    - tenv
+    - staticcheck
     - testableexamples
-    - typecheck
     - unconvert
     - unparam
     - unused
-    # - varnamelen TODO: review naming
-    # - varcheck depricated 1.49
-    # - wastedassign disabled because of generics
     - whitespace
     - wrapcheck
-    # - wsl
-
-issues:
-  exclude-rules:
-    - path: _test\.go
-      linters:
-        - funlen
-        - bodyclose
-        - gosec
-        - dupl
-        - gocognit
-        - goconst
-        - gocyclo
-  exclude:
-    - Using the variable on range scope `tt` in function literal
+  settings:
+    dupl:
+      threshold: 100
+    funlen:
+      lines: 105
+      statements: 50
+    goconst:
+      min-len: 2
+      min-occurrences: 2
+    gocritic:
+      disabled-checks:
+        - dupImport
+        - ifElseChain
+        - octalLiteral
+        - rangeValCopy
+        - unnamedResult
+        - whyNoLint
+        - wrapperFunc
+      enabled-tags:
+        - diagnostic
+        - experimental
+        - opinionated
+        - performance
+        - style
+    gocyclo:
+      min-complexity: 15
+    misspell:
+      locale: US
+      ignore-rules:
+        - cancelled
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    rules:
+      - linters:
+          - bodyclose
+          - dupl
+          - funlen
+          - gocognit
+          - goconst
+          - gocyclo
+          - gosec
+        path: _test\.go
+      - path: (.+)\.go$
+        text: Using the variable on range scope `tt` in function literal
+    paths:
+      - mocks$
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  enable:
+    - gci
+    - gofmt
+    - goimports
+  settings:
+    gci:
+      sections:
+        - standard
+        - default
+        - prefix(secrets-init)
+      custom-order: true
+    goimports:
+      local-prefixes:
+        - secrets-init
+  exclusions:
+    generated: lax
+    paths:
+      - mocks$
+      - third_party$
+      - builtin$
+      - examples$
diff --git a/.mockery.yml b/.mockery.yml
new file mode 100644
index 0000000..e7cad92
--- /dev/null
+++ b/.mockery.yml
@@ -0,0 +1,20 @@
+all: false
+dir: mocks
+filename: '{{.InterfaceName}}.go'
+force-file-write: true
+formatter: goimports
+log-level: warn
+pkgname: mocks
+structname: '{{.InterfaceName}}'
+template: testify
+packages:
+  secrets-init/pkg/secrets/aws:
+    interfaces:
+      SecretsManagerAPI:
+      SSMAPI:
+  secrets-init/pkg/secrets/google:
+    interfaces:
+      SecretsManagerAPI:
+        config:
+          filename: GoogleSecretsManagerAPI.go
+          structname: GoogleSecretsManagerAPI
diff --git a/Dockerfile b/Dockerfile
index 4541674..bda2506 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,27 +1,28 @@
-# syntax = docker/dockerfile:experimental
+# syntax=docker/dockerfile:1
 
-FROM --platform=${BUILDPLATFORM} golang:1.22-alpine as builder
+FROM --platform=${BUILDPLATFORM} golang:1.26.5-alpine AS builder
 # passed by buildkit
 ARG TARGETOS
 ARG TARGETARCH
+ARG VERSION=v0
 # add CA certificates and TZ for local time
-RUN apk --update add ca-certificates make git
+RUN apk add --no-cache ca-certificates make git
 # Create and change to the app directory.
 RUN mkdir -p /go/src/app
 WORKDIR /go/src/app
 # Retrieve application dependencies.
 # This allows the container build to reuse cached dependencies.
 # Expecting to copy go.mod and if present go.sum.
-COPY go.mod .
-COPY go.sum .
-RUN --mount=type=cache,target=/go/mod go mod download
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=/go/pkg/mod go mod download
 # Copy local code to the container image.
 COPY . .
 # Build the binary.
-RUN --mount=type=cache,target=/root/.cache/go-build TARGETOS=${TARGETOS} TARGETARCH=${TARGETARCH} make
+RUN --mount=type=cache,target=/root/.cache/go-build \
+    TARGETOS=${TARGETOS} TARGETARCH=${TARGETARCH} make VERSION=${VERSION}
 
 # final image
-FROM busybox:1.36
+FROM busybox:1.38.0
 # copy certificates
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 # copy the binary to the production image from the builder stage.
diff --git a/Makefile b/Makefile
index 92f1e1a..d74972c 100644
--- a/Makefile
+++ b/Makefile
@@ -36,23 +36,28 @@ all: fmt lint test ; $(info $(M) building executable...) @ ## Build program bina
 
 # Release for multiple platforms
 
-.PHONY: platfrom-build
-platfrom-build: clean lint test ; $(info $(M) building binaries for multiple os/arch...) @ ## Build program binary for platforms and os
-	$(foreach GOOS, $(PLATFORMS),\
-		$(foreach GOARCH, $(ARCHITECTURES), \
-			$(shell \
-				GOPROXY=$(GOPROXY) CGO_ENABLED=$(CGO_ENABLED) GOOS=$(GOOS) GOARCH=$(GOARCH) \
+.PHONY: platform-build platfrom-build
+platform-build: clean lint test ; $(info $(M) building binaries for multiple os/arch...) @ ## Build program binary for platforms and os
+	$Q set -eu; \
+	for target_os in $(PLATFORMS); do \
+		for target_arch in $(ARCHITECTURES); do \
+			GOPROXY=$(GOPROXY) CGO_ENABLED=$(CGO_ENABLED) GOOS=$$target_os GOARCH=$$target_arch \
 				$(GO) build \
 				-tags release \
-				-ldflags "$(LDFLAGS_VERSION) -X main.Platform=$(GOOS)/$(GOARCH)" \
-				-o $(BIN)/$(basename $(MODULE))-$(GOOS)-$(GOARCH) main.go || true)))
+				-ldflags "$(LDFLAGS_VERSION) -X main.Platform=$$target_os/$$target_arch" \
+				-o $(BIN)/$(basename $(MODULE))-$$target_os-$$target_arch main.go; \
+		done; \
+	done
+
+# Keep the misspelled target for existing callers.
+platfrom-build: platform-build
 
 # Tools
 
 setup-tools: setup-lint setup-gocov setup-gocov-xml setup-go2xunit setup-mockery setup-ghr
 
 setup-lint:
-	$(GO) install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.59.1
+	$(GO) install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.12.2
 setup-gocov:
 	$(GO) install github.com/axw/gocov/...
 setup-gocov-xml:
@@ -60,7 +65,7 @@ setup-gocov-xml:
 setup-go2xunit:
 	$(GO) install github.com/tebeka/go2xunit
 setup-mockery:
-	$(GO) install github.com/vektra/mockery/v2/
+	$(GO) install github.com/vektra/mockery/v3@v3.7.1
 setup-ghr:
 	$(GO) install github.com/tcnksm/ghr@v0.13.0
 
@@ -115,12 +120,8 @@ fmt: ; $(info $(M) running gofmt...) @ ## Run gofmt on all source files
 	$Q $(GO) fmt $(PKGS)
 
 .PHONY: mock
-mock: ; $(info $(M) generating mocks...) @ ## Run mockery
-	$Q $(GO) mod vendor -v
-	$Q $(GOMOCK) --name SecretsManagerAPI --dir vendor/github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface
-	$Q $(GOMOCK) --name SSMAPI --dir vendor/github.com/aws/aws-sdk-go/service/ssm/ssmiface
-	$Q $(GOMOCK) --name GoogleSecretsManagerAPI --dir pkg/secrets/google
-	$Q rm -rf vendor
+mock: setup-mockery ; $(info $(M) generating mocks...) @ ## Run mockery
+	$Q $(GOMOCK)
 
 # Misc
 
diff --git a/go.mod b/go.mod
index fe1c93d..906722a 100644
--- a/go.mod
+++ b/go.mod
@@ -1,45 +1,70 @@
 module secrets-init
 
-go 1.22
+go 1.26
 
 require (
-	cloud.google.com/go/compute v1.10.0
-	cloud.google.com/go/secretmanager v1.8.0
-	github.com/aws/aws-sdk-go v1.44.128
-	github.com/googleapis/gax-go/v2 v2.6.0
+	cloud.google.com/go/compute/metadata v0.9.0
+	cloud.google.com/go/secretmanager v1.20.0
+	github.com/aws/aws-sdk-go-v2 v1.42.1
+	github.com/aws/aws-sdk-go-v2/config v1.32.30
+	github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.43.1
+	github.com/aws/aws-sdk-go-v2/service/ssm v1.72.0
+	github.com/googleapis/gax-go/v2 v2.23.0
 	github.com/pkg/errors v0.9.1
-	github.com/sirupsen/logrus v1.9.0
-	github.com/stretchr/testify v1.8.1
-	github.com/urfave/cli/v2 v2.23.0
-	golang.org/x/sys v0.12.0
-	google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e
+	github.com/sirupsen/logrus v1.9.4
+	github.com/stretchr/testify v1.11.1
+	github.com/tidwall/gjson v1.19.0
+	github.com/urfave/cli/v2 v2.27.7
+	golang.org/x/sys v0.47.0
 )
 
 require (
-	cloud.google.com/go/iam v0.5.0 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/go-cmp v0.5.9 // indirect
-	github.com/googleapis/enterprise-certificate-proxy v0.2.0 // indirect
-	github.com/jmespath/go-jmespath v0.4.0 // indirect
-	github.com/kr/pretty v0.1.0 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
+	cloud.google.com/go/auth v0.22.0 // indirect
+	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
+	cloud.google.com/go/iam v1.12.0 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.19.29 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.30 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.30 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.30 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.31 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.13 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.30 // indirect
+	github.com/aws/aws-sdk-go-v2/service/signin v1.4.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.32.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.37.1 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.44.1 // indirect
+	github.com/aws/smithy-go v1.27.3 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/felixge/httpsnoop v1.1.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/google/s2a-go v0.1.9 // indirect
+	github.com/googleapis/enterprise-certificate-proxy v0.3.18 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/stretchr/objx v0.5.0 // indirect
-	github.com/tidwall/gjson v1.18.0 // indirect
-	github.com/tidwall/match v1.1.1 // indirect
+	github.com/stretchr/objx v0.5.3 // indirect
+	github.com/tidwall/match v1.2.0 // indirect
 	github.com/tidwall/pretty v1.2.1 // indirect
-	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
-	go.opencensus.io v0.23.0 // indirect
-	golang.org/x/net v0.15.0 // indirect
-	golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1 // indirect
-	golang.org/x/text v0.13.0 // indirect
-	google.golang.org/api v0.99.0 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/grpc v1.50.1 // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342 // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.69.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect
+	go.opentelemetry.io/otel v1.44.0 // indirect
+	go.opentelemetry.io/otel/metric v1.44.0 // indirect
+	go.opentelemetry.io/otel/trace v1.44.0 // indirect
+	golang.org/x/crypto v0.54.0 // indirect
+	golang.org/x/net v0.57.0 // indirect
+	golang.org/x/oauth2 v0.36.0 // indirect
+	golang.org/x/sync v0.22.0 // indirect
+	golang.org/x/text v0.40.0 // indirect
+	golang.org/x/time v0.15.0 // indirect
+	google.golang.org/api v0.289.0 // indirect
+	google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20260715232425-e75dac1f907d // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260715232425-e75dac1f907d // indirect
+	google.golang.org/grpc v1.82.1 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index 126c917..35c14b9 100644
--- a/go.sum
+++ b/go.sum
@@ -1,181 +1,155 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.104.0 h1:gSmWO7DY1vOm0MVU6DNXM11BWHHsTUmsC5cv1fuW5X8=
-cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA=
-cloud.google.com/go/compute v1.10.0 h1:aoLIYaA1fX3ywihqpBk2APQKOo20nXsp1GEZQbx5Jk4=
-cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU=
-cloud.google.com/go/iam v0.5.0 h1:fz9X5zyTWBmamZsqvqZqD7khbifcZF/q+Z1J8pfhIUg=
-cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc=
-cloud.google.com/go/secretmanager v1.8.0 h1:4wYWL2t10q+xUtFFS0QuWlqwQguMrwC6FDpjtMM6cUI=
-cloud.google.com/go/secretmanager v1.8.0/go.mod h1:hnVgi/bN5MYHd3Gt0SPuTPPp5ENina1/LxM+2W9U9J4=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/aws/aws-sdk-go v1.44.128 h1:X34pX5t0LIZXjBY11yf9JKMP3c1aZgirh+5PjtaZyJ4=
-github.com/aws/aws-sdk-go v1.44.128/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
-github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-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/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/enterprise-certificate-proxy v0.2.0 h1:y8Yozv7SZtlU//QXbezB6QkpuE6jMD2/gfzk4AftXjs=
-github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg=
-github.com/googleapis/gax-go/v2 v2.6.0 h1:SXk3ABtQYDT/OH8jAyvEOQ58mgawq5C4o/4/89qN2ZU=
-github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY=
-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=
+cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE=
+cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU=
+cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ=
+cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s=
+cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc=
+cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c=
+cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs=
+cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10=
+cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk=
+cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY=
+cloud.google.com/go/secretmanager v1.20.0 h1:GjE3NoyFXo7ipRPy26PMmg4oRX1Ra8fswH45r16rWV0=
+cloud.google.com/go/secretmanager v1.20.0/go.mod h1:9OmSuOeiiUicANglrbdKWSnT3gYkRcXuUQDk7dDW0zU=
+github.com/aws/aws-sdk-go-v2 v1.42.1 h1:9eOTgu1z/dVtYpNZ3/8/XbbaX0x/BqE3HUzAzs6K0ek=
+github.com/aws/aws-sdk-go-v2 v1.42.1/go.mod h1:5pKeft2eJj+gElQ38Jqg4ibCqh+/AK33/0X3hip7IjM=
+github.com/aws/aws-sdk-go-v2/config v1.32.30 h1:XwsEzpTJfQYJbFicz/QMLwAZdyeNVVoOEkbF7R3gPJk=
+github.com/aws/aws-sdk-go-v2/config v1.32.30/go.mod h1:Ud32SuMc+/9BGxfpSVld7HrE2o05JwKmXY4M3jOQNZU=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.29 h1:WHZGssHH887cO0ox07SIQZsFx3MKD4ps6w0xUEmnKYQ=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.29/go.mod h1:Mhl0xR6zjguiuj00XRx2wMx22sAltk7oya39sT7fdg8=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.30 h1:/hi1JADLEW9YYryEz1w4GQu0EtP23pP553Cf9KgsDV4=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.30/go.mod h1:/3AOgy4K17Dm4ucMZVC/MJkzy5kmfKUcINRHZyo0koQ=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.30 h1:xM/Is9cKMHa8Jj8zkvWhvrFkZsXJV9E+BB4g0HW0duQ=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.30/go.mod h1:WueJeNDZvK1fMYEWJIkcivBfEzUkTpBhzlrUKKY8EuA=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.30 h1:jn46zC9LdsVR/ZpMIJqMqb8hHv31BlLx3ulVqNspUOk=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.30/go.mod h1:1hTMsAgbdS/AtUi4bw8+gUuh1pceo+eXRLfpSuSQj3M=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.31 h1:3GUprIsfmGcC5SACIyB0e7E0BM1O1b3Erl5CePYIAeQ=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.31/go.mod h1:7PuV1yl5e2xnUbm+RqvVg5i2iBM8EyijZNoI9wsOoOc=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.13 h1:mbRIur/BiHK6SKPjoBIXSE/hJ6g6JGRLuxQy1jGjlN4=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.13/go.mod h1:ITg9em2KbJx1s0y4aqRX5OYWG6HBZ5TVR//OdpEZ2CQ=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.30 h1:/Z5jmNrKsSD7EmDjzAPsm/3L9IuOkzaynklJZ1qX7S4=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.30/go.mod h1:lEzEZnOosE7zi8Z6royW1cFJTD9fpab4Ul1SBrllewk=
+github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.43.1 h1:ZI18/nuaDBwwMJ95paJrb4NT2TbqEvptj/rlMkEO7DI=
+github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.43.1/go.mod h1:oUyL28WfxY0RqPhFpkrWZx26Cu4JlyrWMMcWq8qqhi0=
+github.com/aws/aws-sdk-go-v2/service/signin v1.4.1 h1:V7ZZ300WPXGjvkyore5DGe0ljVPOxCXie/thWdtSBXE=
+github.com/aws/aws-sdk-go-v2/service/signin v1.4.1/go.mod h1:mxC0nT/C8wMMS97DemZPzvUZxvIt+2Iq+eS3JdFZGgg=
+github.com/aws/aws-sdk-go-v2/service/ssm v1.72.0 h1:jl+7QcR+PEJVQXK1W5NSXw9EKd+w7Cu4Pwj/WvUIHb0=
+github.com/aws/aws-sdk-go-v2/service/ssm v1.72.0/go.mod h1:xabzRvdbMs3FG9kU5M6RUOuCW6wXDkpdIqoXXNzA1nQ=
+github.com/aws/aws-sdk-go-v2/service/sso v1.32.1 h1:gYFYh4iLLcAOJRLNPY2aD2g9DIhKn4eof8UkIrr1rTk=
+github.com/aws/aws-sdk-go-v2/service/sso v1.32.1/go.mod h1:u8af9Nqkmqnr96f7v9nHqzZT9XBwbXEkTiqT4ROuJSE=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.37.1 h1:arjT9Cm3/WYbGmD5TUZHk4UQn4Lle1fUNZs5FC6CtF0=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.37.1/go.mod h1:DMPWJBjYs6+3+f/qhBFEFPPlQ6NlhWjai3dJNvipJ84=
+github.com/aws/aws-sdk-go-v2/service/sts v1.44.1 h1:RvfHDg+xvAeZ+5741vUEjpOVtYSIm93W2zhx10Xtydw=
+github.com/aws/aws-sdk-go-v2/service/sts v1.44.1/go.mod h1:9gdl4RrflIdpDb2TlXshWgR1F9TeCkvqDx77Vpr4Z/Q=
+github.com/aws/smithy-go v1.27.3 h1:F3Zb497UhhskkfpJmfkXswyo+t0sh9OTBnIHjogWbVY=
+github.com/aws/smithy-go v1.27.3/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os8IaYg++6uMOdKK83QtkkvJik=
+github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4=
+github.com/cpuguy83/go-md2man/v2 v2.0.7 h1:zbFlGlXEAKlwXpmvle3d8Oe3YnkKIK4xSRTd3sHPnBo=
+github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/envoyproxy/go-control-plane v0.14.0 h1:hbG2kr4RuFj222B6+7T83thSPqLjwBIfQawTkC++2HA=
+github.com/envoyproxy/go-control-plane/envoy v1.37.0 h1:u3riX6BoYRfF4Dr7dwSOroNfdSbEPe9Yyl09/B6wBrQ=
+github.com/envoyproxy/go-control-plane/envoy v1.37.0/go.mod h1:DReE9MMrmecPy+YvQOAOHNYMALuowAnbjjEMkkWOi6A=
+github.com/envoyproxy/protoc-gen-validate v1.3.3 h1:MVQghNeW+LZcmXe7SY1V36Z+WFMDjpqGAGacLe2T0ds=
+github.com/envoyproxy/protoc-gen-validate v1.3.3/go.mod h1:TsndJ/ngyIdQRhMcVVGDDHINPLWB7C82oDArY51KfB0=
+github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc=
+github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0=
+github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/enterprise-certificate-proxy v0.3.18 h1:hvVi34VucdrV1IIsiWuqYM8kutw/92MxNEFxCJZEh0k=
+github.com/googleapis/enterprise-certificate-proxy v0.3.18/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k=
+github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE=
+github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 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/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo=
+github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
-github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
-github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
-github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
-github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
-github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w=
+github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g=
+github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4=
+github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tidwall/gjson v1.19.0 h1:xwxm7n691Uf3u5OFjzngavjGTh55KX5q/9w9xHW88JU=
+github.com/tidwall/gjson v1.19.0/go.mod h1:V37/opeE/JbLUOfH0QTXiNez2l0RUjYUhpT4szFQAfc=
+github.com/tidwall/match v1.2.0 h1:0pt8FlkOwjN2fPt4bIl4BoNxb98gGHN2ObFEDkrfZnM=
+github.com/tidwall/match v1.2.0/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
 github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
 github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
-github.com/urfave/cli/v2 v2.23.0 h1:pkly7gKIeYv3olPAeNajNpLjeJrmTPYCoZWaV+2VfvE=
-github.com/urfave/cli/v2 v2.23.0/go.mod h1:1CNUng3PtjQMtRzJO4FMXBQvkGtuYRxxiR9xMa7jMwI=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
-go.opencensus.io v0.23.0 h1:gqCw0LfLxScz8irSi8exQc7fyQ0fKQU/qnC/X8+V/1M=
-go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
-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/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/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-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.15.0 h1:ugBLEUaxABaB5AJqW9enI0ACdci2RUd4eP51NTBvuJ8=
-golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1 h1:3VPzK7eqH25j7GYw5w6g/GzNRc0/fYtrxz27z1gD4W0=
-golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/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-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/api v0.99.0 h1:tsBtOIklCE2OFxhmcYSVqGwSAN/Y897srxmcvAQnwK8=
-google.golang.org/api v0.99.0/go.mod h1:1YOf74vkVndF7pG6hIHuINsM7eWwpVTAfNMNiL91A08=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
-google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e h1:halCgTFuLWDRD61piiNSxPsARANGD3Xl16hPrLgLiIg=
-google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.50.1 h1:DS/BukOZWp8s6p4Dt/tOaJaTQyPyOoCcrjroHuCeLzY=
-google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
-google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+github.com/urfave/cli/v2 v2.27.7 h1:bH59vdhbjLv3LAvIu6gd0usJHgoTTPhCFib8qqOwXYU=
+github.com/urfave/cli/v2 v2.27.7/go.mod h1:CyNAG/xg+iAOg0N4MPGZqVmv2rCoP267496AOXUZjA4=
+github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342 h1:FnBeRrxr7OU4VvAzt5X7s6266i6cSVkkFPS0TuXWbIg=
+github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.69.0 h1:2yEATaop1/a1I4psnSLgWVPLWwCzkqWakgJy7xTDVy0=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.69.0/go.mod h1:D7J12YRapIekYyPWgGPlA/23pRmpSEZC5xJC/TTLI9U=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI=
+go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU=
+go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc=
+go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc=
+go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo=
+go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58=
+go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0=
+go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI=
+go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA=
+go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk=
+go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE=
+golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
+golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
+golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
+golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
+golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
+golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
+golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
+golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
+golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
+gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
+gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
+google.golang.org/api v0.289.0 h1:DmH0c6NigNFmsvsohM9bxv+MzVhag3aGHnojA5fFQjc=
+google.golang.org/api v0.289.0/go.mod h1:weJZ3lldHFYI0DBFNKpJelUDNnusTt5YaOEgxvt8ci8=
+google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d h1:C9v1o0/4quuhOAfmRXA2j+we0PqZIp8traLdeogF3Ms=
+google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU=
+google.golang.org/genproto/googleapis/api v0.0.0-20260715232425-e75dac1f907d h1:QwnJwPte4XXAkhPu26LTDIahnsMSUV0kK8HkxbC+Pc4=
+google.golang.org/genproto/googleapis/api v0.0.0-20260715232425-e75dac1f907d/go.mod h1:WRrQ7/7N19PypuT0fxLOL5Lq0waoiRri4FbtHDEKrGE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260715232425-e75dac1f907d h1:Jkpk39hlTZOIp3RbfvNX9R8Hv+Sw0X89nlU/xFOErsc=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260715232425-e75dac1f907d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
+google.golang.org/grpc v1.82.1 h1:NnAxzGRA0677vCa4BUkOAnO5+FfQqVl9iUXeD0IqcGE=
+google.golang.org/grpc v1.82.1/go.mod h1:yzTZ1TB1Z3SG+LIYaI+WiE8D5+PZ3ArnrSp8zF3+/ZA=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
diff --git a/main.go b/main.go
index 76d6714..9d37e65 100644
--- a/main.go
+++ b/main.go
@@ -11,14 +11,14 @@ import (
 	"runtime"
 	"syscall"
 
-	"secrets-init/pkg/secrets" //nolint:gci
-	"secrets-init/pkg/secrets/aws"
-	"secrets-init/pkg/secrets/google"
-
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 	cli "github.com/urfave/cli/v2"
-	"golang.org/x/sys/unix" //nolint:gci
+	"golang.org/x/sys/unix"
+
+	"secrets-init/pkg/secrets"
+	"secrets-init/pkg/secrets/aws"
+	"secrets-init/pkg/secrets/google"
 )
 
 var (
@@ -34,6 +34,14 @@ var (
 	Platform = ""
 )
 
+const (
+	logFormatJSON = "json"
+	logFormatText = "text"
+	providerAWS   = "aws"
+	providerGCP   = "google"
+	logFieldArgs  = "args"
+)
+
 func main() {
 	app := &cli.App{
 		Before: setLogFormatter,
@@ -41,13 +49,13 @@ func main() {
 			&cli.StringFlag{
 				Name:    "log-format, l",
 				Usage:   "select logrus formatter ['json', 'text']",
-				Value:   "text",
+				Value:   logFormatText,
 				EnvVars: []string{"SECRETS_INIT_LOG_FORMAT", "LOG_FORMAT"},
 			},
 			&cli.StringFlag{
 				Name:    "provider, p",
 				Usage:   "supported secrets manager provider ['aws', 'google']",
-				Value:   "aws",
+				Value:   providerAWS,
 				EnvVars: []string{"SECRETS_INIT_SECRETS_PROVIDER", "SECRETS_PROVIDER"},
 			},
 			&cli.BoolFlag{
@@ -100,7 +108,10 @@ func copyCmd(c *cli.Context) error {
 		return errors.New("must specify copy destination")
 	}
 	// full path of current executable
-	src := os.Args[0]
+	src, err := os.Executable()
+	if err != nil {
+		return errors.Wrap(err, "failed to resolve source file")
+	}
 	// destination path
 	dest := filepath.Join(c.Args().First(), filepath.Base(src))
 	// copy file with current file mode flags
@@ -142,9 +153,9 @@ func mainCmd(c *cli.Context) error {
 	// get provider
 	var provider secrets.Provider
 	var err error
-	if c.String("provider") == "aws" {
-		provider, err = aws.NewAwsSecretsProvider()
-	} else if c.String("provider") == "google" {
+	if c.String("provider") == providerAWS {
+		provider, err = aws.NewAwsSecretsProvider(ctx)
+	} else if c.String("provider") == providerGCP {
 		provider, err = google.NewGoogleSecretsProvider(ctx, c.String("google-project"))
 	}
 	if err != nil {
@@ -247,9 +258,9 @@ func run(ctx context.Context, provider secrets.Provider, exitEarly, interactive
 
 	// start the specified command
 	log.WithFields(log.Fields{
-		"command": commandStr,
-		"args":    argsSlice,
-		"env":     cmd.Env,
+		"command":    commandStr,
+		logFieldArgs: argsSlice,
+		"env":        cmd.Env,
 	}).Debug("starting command")
 	err = cmd.Start()
 	if err != nil {
@@ -270,10 +281,10 @@ func run(ctx context.Context, provider secrets.Provider, exitEarly, interactive
 				e := syscall.Kill(-cmd.Process.Pid, sig.(syscall.Signal))
 				if e != nil {
 					log.WithFields(log.Fields{
-						"pid":    cmd.Process.Pid,
-						"path":   cmd.Path,
-						"args":   cmd.Args,
-						"signal": unix.SignalName(sig.(syscall.Signal)),
+						"pid":        cmd.Process.Pid,
+						"path":       cmd.Path,
+						logFieldArgs: cmd.Args,
+						"signal":     unix.SignalName(sig.(syscall.Signal)),
 					}).WithError(e).Error("failed to send system signal to the process")
 				}
 			}
@@ -284,9 +295,9 @@ func run(ctx context.Context, provider secrets.Provider, exitEarly, interactive
 }
 
 func setLogFormatter(c *cli.Context) error {
-	if c.String("log-format") == "json" {
+	if c.String("log-format") == logFormatJSON {
 		log.SetFormatter(&log.JSONFormatter{})
-	} else if c.String("log-format") == "text" {
+	} else if c.String("log-format") == logFormatText {
 		log.SetFormatter(&log.TextFormatter{})
 	}
 	return nil
diff --git a/mocks/GoogleSecretsManagerAPI.go b/mocks/GoogleSecretsManagerAPI.go
index 49933ab..0fb1819 100644
--- a/mocks/GoogleSecretsManagerAPI.go
+++ b/mocks/GoogleSecretsManagerAPI.go
@@ -1,63 +1,123 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks
 
 import (
-	context "context"
-
-	gax "github.com/googleapis/gax-go/v2"
+	"context"
 
+	"cloud.google.com/go/secretmanager/apiv1/secretmanagerpb"
+	"github.com/googleapis/gax-go/v2"
 	mock "github.com/stretchr/testify/mock"
-
-	secretmanager "google.golang.org/genproto/googleapis/cloud/secretmanager/v1"
 )
 
-// GoogleSecretsManagerAPI is an autogenerated mock type for the GoogleSecretsManagerAPI type
+// NewGoogleSecretsManagerAPI creates a new instance of GoogleSecretsManagerAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewGoogleSecretsManagerAPI(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *GoogleSecretsManagerAPI {
+	mock := &GoogleSecretsManagerAPI{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// GoogleSecretsManagerAPI is an autogenerated mock type for the SecretsManagerAPI type
 type GoogleSecretsManagerAPI struct {
 	mock.Mock
 }
 
-// AccessSecretVersion provides a mock function with given fields: ctx, req, opts
-func (_m *GoogleSecretsManagerAPI) AccessSecretVersion(ctx context.Context, req *secretmanager.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanager.AccessSecretVersionResponse, error) {
-	_va := make([]interface{}, len(opts))
-	for _i := range opts {
-		_va[_i] = opts[_i]
+type GoogleSecretsManagerAPI_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *GoogleSecretsManagerAPI) EXPECT() *GoogleSecretsManagerAPI_Expecter {
+	return &GoogleSecretsManagerAPI_Expecter{mock: &_m.Mock}
+}
+
+// AccessSecretVersion provides a mock function for the type GoogleSecretsManagerAPI
+func (_mock *GoogleSecretsManagerAPI) AccessSecretVersion(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, req, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, req)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for AccessSecretVersion")
 	}
-	var _ca []interface{}
-	_ca = append(_ca, ctx, req)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretmanager.AccessSecretVersionResponse
-	if rf, ok := ret.Get(0).(func(context.Context, *secretmanager.AccessSecretVersionRequest, ...gax.CallOption) *secretmanager.AccessSecretVersionResponse); ok {
-		r0 = rf(ctx, req, opts...)
+
+	var r0 *secretmanagerpb.AccessSecretVersionResponse
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *secretmanagerpb.AccessSecretVersionRequest, ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error)); ok {
+		return returnFunc(ctx, req, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *secretmanagerpb.AccessSecretVersionRequest, ...gax.CallOption) *secretmanagerpb.AccessSecretVersionResponse); ok {
+		r0 = returnFunc(ctx, req, opts...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretmanager.AccessSecretVersionResponse)
+			r0 = ret.Get(0).(*secretmanagerpb.AccessSecretVersionResponse)
 		}
 	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretmanager.AccessSecretVersionRequest, ...gax.CallOption) error); ok {
-		r1 = rf(ctx, req, opts...)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *secretmanagerpb.AccessSecretVersionRequest, ...gax.CallOption) error); ok {
+		r1 = returnFunc(ctx, req, opts...)
 	} else {
 		r1 = ret.Error(1)
 	}
-
 	return r0, r1
 }
 
-type mockConstructorTestingTNewGoogleSecretsManagerAPI interface {
-	mock.TestingT
-	Cleanup(func())
+// GoogleSecretsManagerAPI_AccessSecretVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AccessSecretVersion'
+type GoogleSecretsManagerAPI_AccessSecretVersion_Call struct {
+	*mock.Call
 }
 
-// NewGoogleSecretsManagerAPI creates a new instance of GoogleSecretsManagerAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewGoogleSecretsManagerAPI(t mockConstructorTestingTNewGoogleSecretsManagerAPI) *GoogleSecretsManagerAPI {
-	mock := &GoogleSecretsManagerAPI{}
-	mock.Mock.Test(t)
+// AccessSecretVersion is a helper method to define mock.On call
+//   - ctx context.Context
+//   - req *secretmanagerpb.AccessSecretVersionRequest
+//   - opts ...gax.CallOption
+func (_e *GoogleSecretsManagerAPI_Expecter) AccessSecretVersion(ctx any, req any, opts ...any) *GoogleSecretsManagerAPI_AccessSecretVersion_Call {
+	return &GoogleSecretsManagerAPI_AccessSecretVersion_Call{Call: _e.mock.On("AccessSecretVersion",
+		append([]any{ctx, req}, opts...)...)}
+}
 
-	t.Cleanup(func() { mock.AssertExpectations(t) })
+func (_c *GoogleSecretsManagerAPI_AccessSecretVersion_Call) Run(run func(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption)) *GoogleSecretsManagerAPI_AccessSecretVersion_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *secretmanagerpb.AccessSecretVersionRequest
+		if args[1] != nil {
+			arg1 = args[1].(*secretmanagerpb.AccessSecretVersionRequest)
+		}
+		var arg2 []gax.CallOption
+		var variadicArgs []gax.CallOption
+		if len(args) > 2 {
+			variadicArgs = args[2].([]gax.CallOption)
+		}
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
+}
 
-	return mock
+func (_c *GoogleSecretsManagerAPI_AccessSecretVersion_Call) Return(accessSecretVersionResponse *secretmanagerpb.AccessSecretVersionResponse, err error) *GoogleSecretsManagerAPI_AccessSecretVersion_Call {
+	_c.Call.Return(accessSecretVersionResponse, err)
+	return _c
+}
+
+func (_c *GoogleSecretsManagerAPI_AccessSecretVersion_Call) RunAndReturn(run func(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error)) *GoogleSecretsManagerAPI_AccessSecretVersion_Call {
+	_c.Call.Return(run)
+	return _c
 }
diff --git a/mocks/SSMAPI.go b/mocks/SSMAPI.go
index 148ac50..84575c2 100644
--- a/mocks/SSMAPI.go
+++ b/mocks/SSMAPI.go
@@ -1,12207 +1,122 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks
 
 import (
-	context "context"
+	"context"
 
-	request "github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go-v2/service/ssm"
 	mock "github.com/stretchr/testify/mock"
-
-	ssm "github.com/aws/aws-sdk-go/service/ssm"
 )
 
-// SSMAPI is an autogenerated mock type for the SSMAPI type
-type SSMAPI struct {
-	mock.Mock
-}
-
-// AddTagsToResource provides a mock function with given fields: _a0
-func (_m *SSMAPI) AddTagsToResource(_a0 *ssm.AddTagsToResourceInput) (*ssm.AddTagsToResourceOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.AddTagsToResourceOutput
-	if rf, ok := ret.Get(0).(func(*ssm.AddTagsToResourceInput) *ssm.AddTagsToResourceOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.AddTagsToResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.AddTagsToResourceInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// AddTagsToResourceRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) AddTagsToResourceRequest(_a0 *ssm.AddTagsToResourceInput) (*request.Request, *ssm.AddTagsToResourceOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.AddTagsToResourceInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.AddTagsToResourceOutput
-	if rf, ok := ret.Get(1).(func(*ssm.AddTagsToResourceInput) *ssm.AddTagsToResourceOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.AddTagsToResourceOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// AddTagsToResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) AddTagsToResourceWithContext(_a0 context.Context, _a1 *ssm.AddTagsToResourceInput, _a2 ...request.Option) (*ssm.AddTagsToResourceOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.AddTagsToResourceOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.AddTagsToResourceInput, ...request.Option) *ssm.AddTagsToResourceOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.AddTagsToResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.AddTagsToResourceInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// AssociateOpsItemRelatedItem provides a mock function with given fields: _a0
-func (_m *SSMAPI) AssociateOpsItemRelatedItem(_a0 *ssm.AssociateOpsItemRelatedItemInput) (*ssm.AssociateOpsItemRelatedItemOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.AssociateOpsItemRelatedItemOutput
-	if rf, ok := ret.Get(0).(func(*ssm.AssociateOpsItemRelatedItemInput) *ssm.AssociateOpsItemRelatedItemOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.AssociateOpsItemRelatedItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.AssociateOpsItemRelatedItemInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// AssociateOpsItemRelatedItemRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) AssociateOpsItemRelatedItemRequest(_a0 *ssm.AssociateOpsItemRelatedItemInput) (*request.Request, *ssm.AssociateOpsItemRelatedItemOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.AssociateOpsItemRelatedItemInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.AssociateOpsItemRelatedItemOutput
-	if rf, ok := ret.Get(1).(func(*ssm.AssociateOpsItemRelatedItemInput) *ssm.AssociateOpsItemRelatedItemOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.AssociateOpsItemRelatedItemOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// AssociateOpsItemRelatedItemWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) AssociateOpsItemRelatedItemWithContext(_a0 context.Context, _a1 *ssm.AssociateOpsItemRelatedItemInput, _a2 ...request.Option) (*ssm.AssociateOpsItemRelatedItemOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.AssociateOpsItemRelatedItemOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.AssociateOpsItemRelatedItemInput, ...request.Option) *ssm.AssociateOpsItemRelatedItemOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.AssociateOpsItemRelatedItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.AssociateOpsItemRelatedItemInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CancelCommand provides a mock function with given fields: _a0
-func (_m *SSMAPI) CancelCommand(_a0 *ssm.CancelCommandInput) (*ssm.CancelCommandOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CancelCommandOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CancelCommandInput) *ssm.CancelCommandOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CancelCommandOutput)
-		}
-	}
+// NewSSMAPI creates a new instance of SSMAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSSMAPI(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SSMAPI {
+	mock := &SSMAPI{}
+	mock.Mock.Test(t)
 
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CancelCommandInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
+	t.Cleanup(func() { mock.AssertExpectations(t) })
 
-	return r0, r1
+	return mock
 }
 
-// CancelCommandRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CancelCommandRequest(_a0 *ssm.CancelCommandInput) (*request.Request, *ssm.CancelCommandOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CancelCommandInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CancelCommandOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CancelCommandInput) *ssm.CancelCommandOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CancelCommandOutput)
-		}
-	}
-
-	return r0, r1
+// SSMAPI is an autogenerated mock type for the SSMAPI type
+type SSMAPI struct {
+	mock.Mock
 }
 
-// CancelCommandWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CancelCommandWithContext(_a0 context.Context, _a1 *ssm.CancelCommandInput, _a2 ...request.Option) (*ssm.CancelCommandOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CancelCommandOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CancelCommandInput, ...request.Option) *ssm.CancelCommandOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CancelCommandOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CancelCommandInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+type SSMAPI_Expecter struct {
+	mock *mock.Mock
 }
 
-// CancelMaintenanceWindowExecution provides a mock function with given fields: _a0
-func (_m *SSMAPI) CancelMaintenanceWindowExecution(_a0 *ssm.CancelMaintenanceWindowExecutionInput) (*ssm.CancelMaintenanceWindowExecutionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CancelMaintenanceWindowExecutionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CancelMaintenanceWindowExecutionInput) *ssm.CancelMaintenanceWindowExecutionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CancelMaintenanceWindowExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CancelMaintenanceWindowExecutionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+func (_m *SSMAPI) EXPECT() *SSMAPI_Expecter {
+	return &SSMAPI_Expecter{mock: &_m.Mock}
 }
 
-// CancelMaintenanceWindowExecutionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CancelMaintenanceWindowExecutionRequest(_a0 *ssm.CancelMaintenanceWindowExecutionInput) (*request.Request, *ssm.CancelMaintenanceWindowExecutionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CancelMaintenanceWindowExecutionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CancelMaintenanceWindowExecutionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CancelMaintenanceWindowExecutionInput) *ssm.CancelMaintenanceWindowExecutionOutput); ok {
-		r1 = rf(_a0)
+// GetParameter provides a mock function for the type SSMAPI
+func (_mock *SSMAPI) GetParameter(context1 context.Context, getParameterInput *ssm.GetParameterInput, fns ...func(*ssm.Options)) (*ssm.GetParameterOutput, error) {
+	var tmpRet mock.Arguments
+	if len(fns) > 0 {
+		tmpRet = _mock.Called(context1, getParameterInput, fns)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CancelMaintenanceWindowExecutionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CancelMaintenanceWindowExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CancelMaintenanceWindowExecutionWithContext(_a0 context.Context, _a1 *ssm.CancelMaintenanceWindowExecutionInput, _a2 ...request.Option) (*ssm.CancelMaintenanceWindowExecutionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
+		tmpRet = _mock.Called(context1, getParameterInput)
 	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
+	ret := tmpRet
 
-	var r0 *ssm.CancelMaintenanceWindowExecutionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CancelMaintenanceWindowExecutionInput, ...request.Option) *ssm.CancelMaintenanceWindowExecutionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CancelMaintenanceWindowExecutionOutput)
-		}
+	if len(ret) == 0 {
+		panic("no return value specified for GetParameter")
 	}
 
+	var r0 *ssm.GetParameterOutput
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CancelMaintenanceWindowExecutionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *ssm.GetParameterInput, ...func(*ssm.Options)) (*ssm.GetParameterOutput, error)); ok {
+		return returnFunc(context1, getParameterInput, fns...)
 	}
-
-	return r0, r1
-}
-
-// CreateActivation provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateActivation(_a0 *ssm.CreateActivationInput) (*ssm.CreateActivationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreateActivationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreateActivationInput) *ssm.CreateActivationOutput); ok {
-		r0 = rf(_a0)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *ssm.GetParameterInput, ...func(*ssm.Options)) *ssm.GetParameterOutput); ok {
+		r0 = returnFunc(context1, getParameterInput, fns...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateActivationOutput)
+			r0 = ret.Get(0).(*ssm.GetParameterOutput)
 		}
 	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreateActivationInput) error); ok {
-		r1 = rf(_a0)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *ssm.GetParameterInput, ...func(*ssm.Options)) error); ok {
+		r1 = returnFunc(context1, getParameterInput, fns...)
 	} else {
 		r1 = ret.Error(1)
 	}
-
-	return r0, r1
-}
-
-// CreateActivationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateActivationRequest(_a0 *ssm.CreateActivationInput) (*request.Request, *ssm.CreateActivationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreateActivationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CreateActivationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreateActivationInput) *ssm.CreateActivationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreateActivationOutput)
-		}
-	}
-
 	return r0, r1
 }
 
-// CreateActivationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreateActivationWithContext(_a0 context.Context, _a1 *ssm.CreateActivationInput, _a2 ...request.Option) (*ssm.CreateActivationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreateActivationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateActivationInput, ...request.Option) *ssm.CreateActivationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateActivationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateActivationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+// SSMAPI_GetParameter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParameter'
+type SSMAPI_GetParameter_Call struct {
+	*mock.Call
 }
 
-// CreateAssociation provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateAssociation(_a0 *ssm.CreateAssociationInput) (*ssm.CreateAssociationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreateAssociationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationInput) *ssm.CreateAssociationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateAssociationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreateAssociationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+// GetParameter is a helper method to define mock.On call
+//   - context1 context.Context
+//   - getParameterInput *ssm.GetParameterInput
+//   - fns ...func(*ssm.Options)
+func (_e *SSMAPI_Expecter) GetParameter(context1 any, getParameterInput any, fns ...any) *SSMAPI_GetParameter_Call {
+	return &SSMAPI_GetParameter_Call{Call: _e.mock.On("GetParameter",
+		append([]any{context1, getParameterInput}, fns...)...)}
 }
 
-// CreateAssociationBatch provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateAssociationBatch(_a0 *ssm.CreateAssociationBatchInput) (*ssm.CreateAssociationBatchOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreateAssociationBatchOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationBatchInput) *ssm.CreateAssociationBatchOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateAssociationBatchOutput)
+func (_c *SSMAPI_GetParameter_Call) Run(run func(context1 context.Context, getParameterInput *ssm.GetParameterInput, fns ...func(*ssm.Options))) *SSMAPI_GetParameter_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
 		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreateAssociationBatchInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateAssociationBatchRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateAssociationBatchRequest(_a0 *ssm.CreateAssociationBatchInput) (*request.Request, *ssm.CreateAssociationBatchOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationBatchInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
+		var arg1 *ssm.GetParameterInput
+		if args[1] != nil {
+			arg1 = args[1].(*ssm.GetParameterInput)
 		}
-	}
-
-	var r1 *ssm.CreateAssociationBatchOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreateAssociationBatchInput) *ssm.CreateAssociationBatchOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreateAssociationBatchOutput)
+		var arg2 []func(*ssm.Options)
+		var variadicArgs []func(*ssm.Options)
+		if len(args) > 2 {
+			variadicArgs = args[2].([]func(*ssm.Options))
 		}
-	}
-
-	return r0, r1
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
 }
 
-// CreateAssociationBatchWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreateAssociationBatchWithContext(_a0 context.Context, _a1 *ssm.CreateAssociationBatchInput, _a2 ...request.Option) (*ssm.CreateAssociationBatchOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreateAssociationBatchOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateAssociationBatchInput, ...request.Option) *ssm.CreateAssociationBatchOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateAssociationBatchOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateAssociationBatchInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+func (_c *SSMAPI_GetParameter_Call) Return(getParameterOutput *ssm.GetParameterOutput, err error) *SSMAPI_GetParameter_Call {
+	_c.Call.Return(getParameterOutput, err)
+	return _c
 }
 
-// CreateAssociationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateAssociationRequest(_a0 *ssm.CreateAssociationInput) (*request.Request, *ssm.CreateAssociationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreateAssociationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CreateAssociationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreateAssociationInput) *ssm.CreateAssociationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreateAssociationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CreateAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreateAssociationWithContext(_a0 context.Context, _a1 *ssm.CreateAssociationInput, _a2 ...request.Option) (*ssm.CreateAssociationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreateAssociationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateAssociationInput, ...request.Option) *ssm.CreateAssociationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateAssociationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateAssociationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateDocument provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateDocument(_a0 *ssm.CreateDocumentInput) (*ssm.CreateDocumentOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreateDocumentOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreateDocumentInput) *ssm.CreateDocumentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreateDocumentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateDocumentRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateDocumentRequest(_a0 *ssm.CreateDocumentInput) (*request.Request, *ssm.CreateDocumentOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreateDocumentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CreateDocumentOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreateDocumentInput) *ssm.CreateDocumentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreateDocumentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CreateDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreateDocumentWithContext(_a0 context.Context, _a1 *ssm.CreateDocumentInput, _a2 ...request.Option) (*ssm.CreateDocumentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreateDocumentOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateDocumentInput, ...request.Option) *ssm.CreateDocumentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateDocumentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateMaintenanceWindow provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateMaintenanceWindow(_a0 *ssm.CreateMaintenanceWindowInput) (*ssm.CreateMaintenanceWindowOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreateMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreateMaintenanceWindowInput) *ssm.CreateMaintenanceWindowOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreateMaintenanceWindowInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateMaintenanceWindowRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateMaintenanceWindowRequest(_a0 *ssm.CreateMaintenanceWindowInput) (*request.Request, *ssm.CreateMaintenanceWindowOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreateMaintenanceWindowInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CreateMaintenanceWindowOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreateMaintenanceWindowInput) *ssm.CreateMaintenanceWindowOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreateMaintenanceWindowOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CreateMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreateMaintenanceWindowWithContext(_a0 context.Context, _a1 *ssm.CreateMaintenanceWindowInput, _a2 ...request.Option) (*ssm.CreateMaintenanceWindowOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreateMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateMaintenanceWindowInput, ...request.Option) *ssm.CreateMaintenanceWindowOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateMaintenanceWindowInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateOpsItem provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateOpsItem(_a0 *ssm.CreateOpsItemInput) (*ssm.CreateOpsItemOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreateOpsItemOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreateOpsItemInput) *ssm.CreateOpsItemOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateOpsItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreateOpsItemInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateOpsItemRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateOpsItemRequest(_a0 *ssm.CreateOpsItemInput) (*request.Request, *ssm.CreateOpsItemOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreateOpsItemInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CreateOpsItemOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreateOpsItemInput) *ssm.CreateOpsItemOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreateOpsItemOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CreateOpsItemWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreateOpsItemWithContext(_a0 context.Context, _a1 *ssm.CreateOpsItemInput, _a2 ...request.Option) (*ssm.CreateOpsItemOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreateOpsItemOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateOpsItemInput, ...request.Option) *ssm.CreateOpsItemOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateOpsItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateOpsItemInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateOpsMetadata provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateOpsMetadata(_a0 *ssm.CreateOpsMetadataInput) (*ssm.CreateOpsMetadataOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreateOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreateOpsMetadataInput) *ssm.CreateOpsMetadataOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreateOpsMetadataInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateOpsMetadataRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateOpsMetadataRequest(_a0 *ssm.CreateOpsMetadataInput) (*request.Request, *ssm.CreateOpsMetadataOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreateOpsMetadataInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CreateOpsMetadataOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreateOpsMetadataInput) *ssm.CreateOpsMetadataOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreateOpsMetadataOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CreateOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreateOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.CreateOpsMetadataInput, _a2 ...request.Option) (*ssm.CreateOpsMetadataOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreateOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateOpsMetadataInput, ...request.Option) *ssm.CreateOpsMetadataOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateOpsMetadataInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreatePatchBaseline provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreatePatchBaseline(_a0 *ssm.CreatePatchBaselineInput) (*ssm.CreatePatchBaselineOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreatePatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreatePatchBaselineInput) *ssm.CreatePatchBaselineOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreatePatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreatePatchBaselineInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreatePatchBaselineRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreatePatchBaselineRequest(_a0 *ssm.CreatePatchBaselineInput) (*request.Request, *ssm.CreatePatchBaselineOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreatePatchBaselineInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CreatePatchBaselineOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreatePatchBaselineInput) *ssm.CreatePatchBaselineOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreatePatchBaselineOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CreatePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreatePatchBaselineWithContext(_a0 context.Context, _a1 *ssm.CreatePatchBaselineInput, _a2 ...request.Option) (*ssm.CreatePatchBaselineOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreatePatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreatePatchBaselineInput, ...request.Option) *ssm.CreatePatchBaselineOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreatePatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreatePatchBaselineInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateResourceDataSync provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateResourceDataSync(_a0 *ssm.CreateResourceDataSyncInput) (*ssm.CreateResourceDataSyncOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.CreateResourceDataSyncOutput
-	if rf, ok := ret.Get(0).(func(*ssm.CreateResourceDataSyncInput) *ssm.CreateResourceDataSyncOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateResourceDataSyncOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.CreateResourceDataSyncInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateResourceDataSyncRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) CreateResourceDataSyncRequest(_a0 *ssm.CreateResourceDataSyncInput) (*request.Request, *ssm.CreateResourceDataSyncOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.CreateResourceDataSyncInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.CreateResourceDataSyncOutput
-	if rf, ok := ret.Get(1).(func(*ssm.CreateResourceDataSyncInput) *ssm.CreateResourceDataSyncOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.CreateResourceDataSyncOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CreateResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) CreateResourceDataSyncWithContext(_a0 context.Context, _a1 *ssm.CreateResourceDataSyncInput, _a2 ...request.Option) (*ssm.CreateResourceDataSyncOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.CreateResourceDataSyncOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.CreateResourceDataSyncInput, ...request.Option) *ssm.CreateResourceDataSyncOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.CreateResourceDataSyncOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.CreateResourceDataSyncInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteActivation provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteActivation(_a0 *ssm.DeleteActivationInput) (*ssm.DeleteActivationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteActivationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteActivationInput) *ssm.DeleteActivationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteActivationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteActivationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteActivationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteActivationRequest(_a0 *ssm.DeleteActivationInput) (*request.Request, *ssm.DeleteActivationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteActivationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteActivationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteActivationInput) *ssm.DeleteActivationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteActivationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteActivationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteActivationWithContext(_a0 context.Context, _a1 *ssm.DeleteActivationInput, _a2 ...request.Option) (*ssm.DeleteActivationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteActivationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteActivationInput, ...request.Option) *ssm.DeleteActivationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteActivationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteActivationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteAssociation provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteAssociation(_a0 *ssm.DeleteAssociationInput) (*ssm.DeleteAssociationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteAssociationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteAssociationInput) *ssm.DeleteAssociationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteAssociationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteAssociationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteAssociationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteAssociationRequest(_a0 *ssm.DeleteAssociationInput) (*request.Request, *ssm.DeleteAssociationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteAssociationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteAssociationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteAssociationInput) *ssm.DeleteAssociationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteAssociationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteAssociationWithContext(_a0 context.Context, _a1 *ssm.DeleteAssociationInput, _a2 ...request.Option) (*ssm.DeleteAssociationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteAssociationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteAssociationInput, ...request.Option) *ssm.DeleteAssociationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteAssociationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteAssociationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteDocument provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteDocument(_a0 *ssm.DeleteDocumentInput) (*ssm.DeleteDocumentOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteDocumentOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteDocumentInput) *ssm.DeleteDocumentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteDocumentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteDocumentRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteDocumentRequest(_a0 *ssm.DeleteDocumentInput) (*request.Request, *ssm.DeleteDocumentOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteDocumentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteDocumentOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteDocumentInput) *ssm.DeleteDocumentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteDocumentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteDocumentWithContext(_a0 context.Context, _a1 *ssm.DeleteDocumentInput, _a2 ...request.Option) (*ssm.DeleteDocumentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteDocumentOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteDocumentInput, ...request.Option) *ssm.DeleteDocumentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteDocumentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteInventory provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteInventory(_a0 *ssm.DeleteInventoryInput) (*ssm.DeleteInventoryOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteInventoryOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteInventoryInput) *ssm.DeleteInventoryOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteInventoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteInventoryInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteInventoryRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteInventoryRequest(_a0 *ssm.DeleteInventoryInput) (*request.Request, *ssm.DeleteInventoryOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteInventoryInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteInventoryOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteInventoryInput) *ssm.DeleteInventoryOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteInventoryOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteInventoryWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteInventoryWithContext(_a0 context.Context, _a1 *ssm.DeleteInventoryInput, _a2 ...request.Option) (*ssm.DeleteInventoryOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteInventoryOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteInventoryInput, ...request.Option) *ssm.DeleteInventoryOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteInventoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteInventoryInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteMaintenanceWindow provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteMaintenanceWindow(_a0 *ssm.DeleteMaintenanceWindowInput) (*ssm.DeleteMaintenanceWindowOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteMaintenanceWindowInput) *ssm.DeleteMaintenanceWindowOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteMaintenanceWindowInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteMaintenanceWindowRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteMaintenanceWindowRequest(_a0 *ssm.DeleteMaintenanceWindowInput) (*request.Request, *ssm.DeleteMaintenanceWindowOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteMaintenanceWindowInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteMaintenanceWindowOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteMaintenanceWindowInput) *ssm.DeleteMaintenanceWindowOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteMaintenanceWindowOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteMaintenanceWindowWithContext(_a0 context.Context, _a1 *ssm.DeleteMaintenanceWindowInput, _a2 ...request.Option) (*ssm.DeleteMaintenanceWindowOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteMaintenanceWindowInput, ...request.Option) *ssm.DeleteMaintenanceWindowOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteMaintenanceWindowInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteOpsMetadata provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteOpsMetadata(_a0 *ssm.DeleteOpsMetadataInput) (*ssm.DeleteOpsMetadataOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteOpsMetadataInput) *ssm.DeleteOpsMetadataOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteOpsMetadataInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteOpsMetadataRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteOpsMetadataRequest(_a0 *ssm.DeleteOpsMetadataInput) (*request.Request, *ssm.DeleteOpsMetadataOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteOpsMetadataInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteOpsMetadataOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteOpsMetadataInput) *ssm.DeleteOpsMetadataOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteOpsMetadataOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.DeleteOpsMetadataInput, _a2 ...request.Option) (*ssm.DeleteOpsMetadataOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteOpsMetadataInput, ...request.Option) *ssm.DeleteOpsMetadataOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteOpsMetadataInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteParameter provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteParameter(_a0 *ssm.DeleteParameterInput) (*ssm.DeleteParameterOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteParameterOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteParameterInput) *ssm.DeleteParameterOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteParameterOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteParameterInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteParameterRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteParameterRequest(_a0 *ssm.DeleteParameterInput) (*request.Request, *ssm.DeleteParameterOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteParameterInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteParameterOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteParameterInput) *ssm.DeleteParameterOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteParameterOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteParameterWithContext(_a0 context.Context, _a1 *ssm.DeleteParameterInput, _a2 ...request.Option) (*ssm.DeleteParameterOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteParameterOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteParameterInput, ...request.Option) *ssm.DeleteParameterOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteParameterOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteParameterInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteParameters provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteParameters(_a0 *ssm.DeleteParametersInput) (*ssm.DeleteParametersOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteParametersOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteParametersInput) *ssm.DeleteParametersOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteParametersOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteParametersInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteParametersRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteParametersRequest(_a0 *ssm.DeleteParametersInput) (*request.Request, *ssm.DeleteParametersOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteParametersInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteParametersOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteParametersInput) *ssm.DeleteParametersOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteParametersOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteParametersWithContext(_a0 context.Context, _a1 *ssm.DeleteParametersInput, _a2 ...request.Option) (*ssm.DeleteParametersOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteParametersOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteParametersInput, ...request.Option) *ssm.DeleteParametersOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteParametersOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteParametersInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeletePatchBaseline provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeletePatchBaseline(_a0 *ssm.DeletePatchBaselineInput) (*ssm.DeletePatchBaselineOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeletePatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeletePatchBaselineInput) *ssm.DeletePatchBaselineOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeletePatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeletePatchBaselineInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeletePatchBaselineRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeletePatchBaselineRequest(_a0 *ssm.DeletePatchBaselineInput) (*request.Request, *ssm.DeletePatchBaselineOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeletePatchBaselineInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeletePatchBaselineOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeletePatchBaselineInput) *ssm.DeletePatchBaselineOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeletePatchBaselineOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeletePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeletePatchBaselineWithContext(_a0 context.Context, _a1 *ssm.DeletePatchBaselineInput, _a2 ...request.Option) (*ssm.DeletePatchBaselineOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeletePatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeletePatchBaselineInput, ...request.Option) *ssm.DeletePatchBaselineOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeletePatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeletePatchBaselineInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteResourceDataSync provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteResourceDataSync(_a0 *ssm.DeleteResourceDataSyncInput) (*ssm.DeleteResourceDataSyncOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeleteResourceDataSyncOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteResourceDataSyncInput) *ssm.DeleteResourceDataSyncOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteResourceDataSyncOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteResourceDataSyncInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteResourceDataSyncRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeleteResourceDataSyncRequest(_a0 *ssm.DeleteResourceDataSyncInput) (*request.Request, *ssm.DeleteResourceDataSyncOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeleteResourceDataSyncInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeleteResourceDataSyncOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeleteResourceDataSyncInput) *ssm.DeleteResourceDataSyncOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeleteResourceDataSyncOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeleteResourceDataSyncWithContext(_a0 context.Context, _a1 *ssm.DeleteResourceDataSyncInput, _a2 ...request.Option) (*ssm.DeleteResourceDataSyncOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeleteResourceDataSyncOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeleteResourceDataSyncInput, ...request.Option) *ssm.DeleteResourceDataSyncOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeleteResourceDataSyncOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeleteResourceDataSyncInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeregisterManagedInstance provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeregisterManagedInstance(_a0 *ssm.DeregisterManagedInstanceInput) (*ssm.DeregisterManagedInstanceOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeregisterManagedInstanceOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeregisterManagedInstanceInput) *ssm.DeregisterManagedInstanceOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeregisterManagedInstanceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeregisterManagedInstanceInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeregisterManagedInstanceRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeregisterManagedInstanceRequest(_a0 *ssm.DeregisterManagedInstanceInput) (*request.Request, *ssm.DeregisterManagedInstanceOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeregisterManagedInstanceInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeregisterManagedInstanceOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeregisterManagedInstanceInput) *ssm.DeregisterManagedInstanceOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeregisterManagedInstanceOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeregisterManagedInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeregisterManagedInstanceWithContext(_a0 context.Context, _a1 *ssm.DeregisterManagedInstanceInput, _a2 ...request.Option) (*ssm.DeregisterManagedInstanceOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeregisterManagedInstanceOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeregisterManagedInstanceInput, ...request.Option) *ssm.DeregisterManagedInstanceOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeregisterManagedInstanceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeregisterManagedInstanceInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeregisterPatchBaselineForPatchGroup provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeregisterPatchBaselineForPatchGroup(_a0 *ssm.DeregisterPatchBaselineForPatchGroupInput) (*ssm.DeregisterPatchBaselineForPatchGroupOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeregisterPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeregisterPatchBaselineForPatchGroupInput) *ssm.DeregisterPatchBaselineForPatchGroupOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeregisterPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeregisterPatchBaselineForPatchGroupInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeregisterPatchBaselineForPatchGroupRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeregisterPatchBaselineForPatchGroupRequest(_a0 *ssm.DeregisterPatchBaselineForPatchGroupInput) (*request.Request, *ssm.DeregisterPatchBaselineForPatchGroupOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeregisterPatchBaselineForPatchGroupInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeregisterPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeregisterPatchBaselineForPatchGroupInput) *ssm.DeregisterPatchBaselineForPatchGroupOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeregisterPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeregisterPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeregisterPatchBaselineForPatchGroupWithContext(_a0 context.Context, _a1 *ssm.DeregisterPatchBaselineForPatchGroupInput, _a2 ...request.Option) (*ssm.DeregisterPatchBaselineForPatchGroupOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeregisterPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeregisterPatchBaselineForPatchGroupInput, ...request.Option) *ssm.DeregisterPatchBaselineForPatchGroupOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeregisterPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeregisterPatchBaselineForPatchGroupInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeregisterTargetFromMaintenanceWindow provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeregisterTargetFromMaintenanceWindow(_a0 *ssm.DeregisterTargetFromMaintenanceWindowInput) (*ssm.DeregisterTargetFromMaintenanceWindowOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeregisterTargetFromMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTargetFromMaintenanceWindowInput) *ssm.DeregisterTargetFromMaintenanceWindowOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeregisterTargetFromMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeregisterTargetFromMaintenanceWindowInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeregisterTargetFromMaintenanceWindowRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeregisterTargetFromMaintenanceWindowRequest(_a0 *ssm.DeregisterTargetFromMaintenanceWindowInput) (*request.Request, *ssm.DeregisterTargetFromMaintenanceWindowOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTargetFromMaintenanceWindowInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeregisterTargetFromMaintenanceWindowOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeregisterTargetFromMaintenanceWindowInput) *ssm.DeregisterTargetFromMaintenanceWindowOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeregisterTargetFromMaintenanceWindowOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeregisterTargetFromMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeregisterTargetFromMaintenanceWindowWithContext(_a0 context.Context, _a1 *ssm.DeregisterTargetFromMaintenanceWindowInput, _a2 ...request.Option) (*ssm.DeregisterTargetFromMaintenanceWindowOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeregisterTargetFromMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeregisterTargetFromMaintenanceWindowInput, ...request.Option) *ssm.DeregisterTargetFromMaintenanceWindowOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeregisterTargetFromMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeregisterTargetFromMaintenanceWindowInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeregisterTaskFromMaintenanceWindow provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeregisterTaskFromMaintenanceWindow(_a0 *ssm.DeregisterTaskFromMaintenanceWindowInput) (*ssm.DeregisterTaskFromMaintenanceWindowOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DeregisterTaskFromMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTaskFromMaintenanceWindowInput) *ssm.DeregisterTaskFromMaintenanceWindowOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeregisterTaskFromMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DeregisterTaskFromMaintenanceWindowInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeregisterTaskFromMaintenanceWindowRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DeregisterTaskFromMaintenanceWindowRequest(_a0 *ssm.DeregisterTaskFromMaintenanceWindowInput) (*request.Request, *ssm.DeregisterTaskFromMaintenanceWindowOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DeregisterTaskFromMaintenanceWindowInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DeregisterTaskFromMaintenanceWindowOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DeregisterTaskFromMaintenanceWindowInput) *ssm.DeregisterTaskFromMaintenanceWindowOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DeregisterTaskFromMaintenanceWindowOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeregisterTaskFromMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DeregisterTaskFromMaintenanceWindowWithContext(_a0 context.Context, _a1 *ssm.DeregisterTaskFromMaintenanceWindowInput, _a2 ...request.Option) (*ssm.DeregisterTaskFromMaintenanceWindowOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DeregisterTaskFromMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DeregisterTaskFromMaintenanceWindowInput, ...request.Option) *ssm.DeregisterTaskFromMaintenanceWindowOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DeregisterTaskFromMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DeregisterTaskFromMaintenanceWindowInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeActivations provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeActivations(_a0 *ssm.DescribeActivationsInput) (*ssm.DescribeActivationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeActivationsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeActivationsInput) *ssm.DescribeActivationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeActivationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeActivationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeActivationsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeActivationsPages(_a0 *ssm.DescribeActivationsInput, _a1 func(*ssm.DescribeActivationsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeActivationsInput, func(*ssm.DescribeActivationsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeActivationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeActivationsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeActivationsInput, _a2 func(*ssm.DescribeActivationsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeActivationsInput, func(*ssm.DescribeActivationsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeActivationsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeActivationsRequest(_a0 *ssm.DescribeActivationsInput) (*request.Request, *ssm.DescribeActivationsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeActivationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeActivationsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeActivationsInput) *ssm.DescribeActivationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeActivationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeActivationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeActivationsWithContext(_a0 context.Context, _a1 *ssm.DescribeActivationsInput, _a2 ...request.Option) (*ssm.DescribeActivationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeActivationsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeActivationsInput, ...request.Option) *ssm.DescribeActivationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeActivationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeActivationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociation provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAssociation(_a0 *ssm.DescribeAssociationInput) (*ssm.DescribeAssociationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeAssociationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationInput) *ssm.DescribeAssociationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAssociationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAssociationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociationExecutionTargets provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAssociationExecutionTargets(_a0 *ssm.DescribeAssociationExecutionTargetsInput) (*ssm.DescribeAssociationExecutionTargetsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeAssociationExecutionTargetsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionTargetsInput) *ssm.DescribeAssociationExecutionTargetsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAssociationExecutionTargetsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAssociationExecutionTargetsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociationExecutionTargetsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeAssociationExecutionTargetsPages(_a0 *ssm.DescribeAssociationExecutionTargetsInput, _a1 func(*ssm.DescribeAssociationExecutionTargetsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionTargetsInput, func(*ssm.DescribeAssociationExecutionTargetsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAssociationExecutionTargetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeAssociationExecutionTargetsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationExecutionTargetsInput, _a2 func(*ssm.DescribeAssociationExecutionTargetsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionTargetsInput, func(*ssm.DescribeAssociationExecutionTargetsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAssociationExecutionTargetsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAssociationExecutionTargetsRequest(_a0 *ssm.DescribeAssociationExecutionTargetsInput) (*request.Request, *ssm.DescribeAssociationExecutionTargetsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionTargetsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeAssociationExecutionTargetsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAssociationExecutionTargetsInput) *ssm.DescribeAssociationExecutionTargetsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeAssociationExecutionTargetsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociationExecutionTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeAssociationExecutionTargetsWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationExecutionTargetsInput, _a2 ...request.Option) (*ssm.DescribeAssociationExecutionTargetsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeAssociationExecutionTargetsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionTargetsInput, ...request.Option) *ssm.DescribeAssociationExecutionTargetsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAssociationExecutionTargetsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeAssociationExecutionTargetsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociationExecutions provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAssociationExecutions(_a0 *ssm.DescribeAssociationExecutionsInput) (*ssm.DescribeAssociationExecutionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeAssociationExecutionsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionsInput) *ssm.DescribeAssociationExecutionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAssociationExecutionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAssociationExecutionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociationExecutionsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeAssociationExecutionsPages(_a0 *ssm.DescribeAssociationExecutionsInput, _a1 func(*ssm.DescribeAssociationExecutionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionsInput, func(*ssm.DescribeAssociationExecutionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAssociationExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeAssociationExecutionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationExecutionsInput, _a2 func(*ssm.DescribeAssociationExecutionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionsInput, func(*ssm.DescribeAssociationExecutionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAssociationExecutionsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAssociationExecutionsRequest(_a0 *ssm.DescribeAssociationExecutionsInput) (*request.Request, *ssm.DescribeAssociationExecutionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationExecutionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeAssociationExecutionsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAssociationExecutionsInput) *ssm.DescribeAssociationExecutionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeAssociationExecutionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociationExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeAssociationExecutionsWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationExecutionsInput, _a2 ...request.Option) (*ssm.DescribeAssociationExecutionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeAssociationExecutionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationExecutionsInput, ...request.Option) *ssm.DescribeAssociationExecutionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAssociationExecutionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeAssociationExecutionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAssociationRequest(_a0 *ssm.DescribeAssociationInput) (*request.Request, *ssm.DescribeAssociationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAssociationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeAssociationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAssociationInput) *ssm.DescribeAssociationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeAssociationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeAssociationWithContext(_a0 context.Context, _a1 *ssm.DescribeAssociationInput, _a2 ...request.Option) (*ssm.DescribeAssociationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeAssociationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAssociationInput, ...request.Option) *ssm.DescribeAssociationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAssociationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeAssociationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAutomationExecutions provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAutomationExecutions(_a0 *ssm.DescribeAutomationExecutionsInput) (*ssm.DescribeAutomationExecutionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeAutomationExecutionsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionsInput) *ssm.DescribeAutomationExecutionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAutomationExecutionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAutomationExecutionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAutomationExecutionsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeAutomationExecutionsPages(_a0 *ssm.DescribeAutomationExecutionsInput, _a1 func(*ssm.DescribeAutomationExecutionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionsInput, func(*ssm.DescribeAutomationExecutionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAutomationExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeAutomationExecutionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAutomationExecutionsInput, _a2 func(*ssm.DescribeAutomationExecutionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationExecutionsInput, func(*ssm.DescribeAutomationExecutionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAutomationExecutionsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAutomationExecutionsRequest(_a0 *ssm.DescribeAutomationExecutionsInput) (*request.Request, *ssm.DescribeAutomationExecutionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationExecutionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeAutomationExecutionsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAutomationExecutionsInput) *ssm.DescribeAutomationExecutionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeAutomationExecutionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeAutomationExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeAutomationExecutionsWithContext(_a0 context.Context, _a1 *ssm.DescribeAutomationExecutionsInput, _a2 ...request.Option) (*ssm.DescribeAutomationExecutionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeAutomationExecutionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationExecutionsInput, ...request.Option) *ssm.DescribeAutomationExecutionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAutomationExecutionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeAutomationExecutionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAutomationStepExecutions provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAutomationStepExecutions(_a0 *ssm.DescribeAutomationStepExecutionsInput) (*ssm.DescribeAutomationStepExecutionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeAutomationStepExecutionsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationStepExecutionsInput) *ssm.DescribeAutomationStepExecutionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAutomationStepExecutionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAutomationStepExecutionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAutomationStepExecutionsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeAutomationStepExecutionsPages(_a0 *ssm.DescribeAutomationStepExecutionsInput, _a1 func(*ssm.DescribeAutomationStepExecutionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationStepExecutionsInput, func(*ssm.DescribeAutomationStepExecutionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAutomationStepExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeAutomationStepExecutionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAutomationStepExecutionsInput, _a2 func(*ssm.DescribeAutomationStepExecutionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationStepExecutionsInput, func(*ssm.DescribeAutomationStepExecutionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAutomationStepExecutionsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAutomationStepExecutionsRequest(_a0 *ssm.DescribeAutomationStepExecutionsInput) (*request.Request, *ssm.DescribeAutomationStepExecutionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAutomationStepExecutionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeAutomationStepExecutionsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAutomationStepExecutionsInput) *ssm.DescribeAutomationStepExecutionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeAutomationStepExecutionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeAutomationStepExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeAutomationStepExecutionsWithContext(_a0 context.Context, _a1 *ssm.DescribeAutomationStepExecutionsInput, _a2 ...request.Option) (*ssm.DescribeAutomationStepExecutionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeAutomationStepExecutionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAutomationStepExecutionsInput, ...request.Option) *ssm.DescribeAutomationStepExecutionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAutomationStepExecutionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeAutomationStepExecutionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAvailablePatches provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAvailablePatches(_a0 *ssm.DescribeAvailablePatchesInput) (*ssm.DescribeAvailablePatchesOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeAvailablePatchesOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAvailablePatchesInput) *ssm.DescribeAvailablePatchesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAvailablePatchesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAvailablePatchesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeAvailablePatchesPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeAvailablePatchesPages(_a0 *ssm.DescribeAvailablePatchesInput, _a1 func(*ssm.DescribeAvailablePatchesOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAvailablePatchesInput, func(*ssm.DescribeAvailablePatchesOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAvailablePatchesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeAvailablePatchesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeAvailablePatchesInput, _a2 func(*ssm.DescribeAvailablePatchesOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAvailablePatchesInput, func(*ssm.DescribeAvailablePatchesOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeAvailablePatchesRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeAvailablePatchesRequest(_a0 *ssm.DescribeAvailablePatchesInput) (*request.Request, *ssm.DescribeAvailablePatchesOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeAvailablePatchesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeAvailablePatchesOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeAvailablePatchesInput) *ssm.DescribeAvailablePatchesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeAvailablePatchesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeAvailablePatchesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeAvailablePatchesWithContext(_a0 context.Context, _a1 *ssm.DescribeAvailablePatchesInput, _a2 ...request.Option) (*ssm.DescribeAvailablePatchesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeAvailablePatchesOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeAvailablePatchesInput, ...request.Option) *ssm.DescribeAvailablePatchesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeAvailablePatchesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeAvailablePatchesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeDocument provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeDocument(_a0 *ssm.DescribeDocumentInput) (*ssm.DescribeDocumentOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeDocumentOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentInput) *ssm.DescribeDocumentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeDocumentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeDocumentPermission provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeDocumentPermission(_a0 *ssm.DescribeDocumentPermissionInput) (*ssm.DescribeDocumentPermissionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeDocumentPermissionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentPermissionInput) *ssm.DescribeDocumentPermissionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeDocumentPermissionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeDocumentPermissionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeDocumentPermissionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeDocumentPermissionRequest(_a0 *ssm.DescribeDocumentPermissionInput) (*request.Request, *ssm.DescribeDocumentPermissionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentPermissionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeDocumentPermissionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeDocumentPermissionInput) *ssm.DescribeDocumentPermissionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeDocumentPermissionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeDocumentPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeDocumentPermissionWithContext(_a0 context.Context, _a1 *ssm.DescribeDocumentPermissionInput, _a2 ...request.Option) (*ssm.DescribeDocumentPermissionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeDocumentPermissionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentPermissionInput, ...request.Option) *ssm.DescribeDocumentPermissionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeDocumentPermissionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeDocumentPermissionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeDocumentRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeDocumentRequest(_a0 *ssm.DescribeDocumentInput) (*request.Request, *ssm.DescribeDocumentOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeDocumentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeDocumentOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeDocumentInput) *ssm.DescribeDocumentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeDocumentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeDocumentWithContext(_a0 context.Context, _a1 *ssm.DescribeDocumentInput, _a2 ...request.Option) (*ssm.DescribeDocumentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeDocumentOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeDocumentInput, ...request.Option) *ssm.DescribeDocumentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeDocumentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeEffectiveInstanceAssociations provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeEffectiveInstanceAssociations(_a0 *ssm.DescribeEffectiveInstanceAssociationsInput) (*ssm.DescribeEffectiveInstanceAssociationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeEffectiveInstanceAssociationsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) *ssm.DescribeEffectiveInstanceAssociationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeEffectiveInstanceAssociationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeEffectiveInstanceAssociationsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeEffectiveInstanceAssociationsPages(_a0 *ssm.DescribeEffectiveInstanceAssociationsInput, _a1 func(*ssm.DescribeEffectiveInstanceAssociationsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectiveInstanceAssociationsInput, func(*ssm.DescribeEffectiveInstanceAssociationsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeEffectiveInstanceAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeEffectiveInstanceAssociationsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeEffectiveInstanceAssociationsInput, _a2 func(*ssm.DescribeEffectiveInstanceAssociationsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeEffectiveInstanceAssociationsInput, func(*ssm.DescribeEffectiveInstanceAssociationsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeEffectiveInstanceAssociationsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeEffectiveInstanceAssociationsRequest(_a0 *ssm.DescribeEffectiveInstanceAssociationsInput) (*request.Request, *ssm.DescribeEffectiveInstanceAssociationsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeEffectiveInstanceAssociationsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeEffectiveInstanceAssociationsInput) *ssm.DescribeEffectiveInstanceAssociationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeEffectiveInstanceAssociationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeEffectiveInstanceAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeEffectiveInstanceAssociationsWithContext(_a0 context.Context, _a1 *ssm.DescribeEffectiveInstanceAssociationsInput, _a2 ...request.Option) (*ssm.DescribeEffectiveInstanceAssociationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeEffectiveInstanceAssociationsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeEffectiveInstanceAssociationsInput, ...request.Option) *ssm.DescribeEffectiveInstanceAssociationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeEffectiveInstanceAssociationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeEffectiveInstanceAssociationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeEffectivePatchesForPatchBaseline provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaseline(_a0 *ssm.DescribeEffectivePatchesForPatchBaselineInput) (*ssm.DescribeEffectivePatchesForPatchBaselineOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeEffectivePatchesForPatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) *ssm.DescribeEffectivePatchesForPatchBaselineOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeEffectivePatchesForPatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeEffectivePatchesForPatchBaselinePages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaselinePages(_a0 *ssm.DescribeEffectivePatchesForPatchBaselineInput, _a1 func(*ssm.DescribeEffectivePatchesForPatchBaselineOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput, func(*ssm.DescribeEffectivePatchesForPatchBaselineOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeEffectivePatchesForPatchBaselinePagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaselinePagesWithContext(_a0 context.Context, _a1 *ssm.DescribeEffectivePatchesForPatchBaselineInput, _a2 func(*ssm.DescribeEffectivePatchesForPatchBaselineOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeEffectivePatchesForPatchBaselineInput, func(*ssm.DescribeEffectivePatchesForPatchBaselineOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeEffectivePatchesForPatchBaselineRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaselineRequest(_a0 *ssm.DescribeEffectivePatchesForPatchBaselineInput) (*request.Request, *ssm.DescribeEffectivePatchesForPatchBaselineOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeEffectivePatchesForPatchBaselineOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeEffectivePatchesForPatchBaselineInput) *ssm.DescribeEffectivePatchesForPatchBaselineOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeEffectivePatchesForPatchBaselineOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeEffectivePatchesForPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeEffectivePatchesForPatchBaselineWithContext(_a0 context.Context, _a1 *ssm.DescribeEffectivePatchesForPatchBaselineInput, _a2 ...request.Option) (*ssm.DescribeEffectivePatchesForPatchBaselineOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeEffectivePatchesForPatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeEffectivePatchesForPatchBaselineInput, ...request.Option) *ssm.DescribeEffectivePatchesForPatchBaselineOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeEffectivePatchesForPatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeEffectivePatchesForPatchBaselineInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstanceAssociationsStatus provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstanceAssociationsStatus(_a0 *ssm.DescribeInstanceAssociationsStatusInput) (*ssm.DescribeInstanceAssociationsStatusOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeInstanceAssociationsStatusOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceAssociationsStatusInput) *ssm.DescribeInstanceAssociationsStatusOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstanceAssociationsStatusOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstanceAssociationsStatusInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstanceAssociationsStatusPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeInstanceAssociationsStatusPages(_a0 *ssm.DescribeInstanceAssociationsStatusInput, _a1 func(*ssm.DescribeInstanceAssociationsStatusOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceAssociationsStatusInput, func(*ssm.DescribeInstanceAssociationsStatusOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstanceAssociationsStatusPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeInstanceAssociationsStatusPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstanceAssociationsStatusInput, _a2 func(*ssm.DescribeInstanceAssociationsStatusOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstanceAssociationsStatusInput, func(*ssm.DescribeInstanceAssociationsStatusOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstanceAssociationsStatusRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstanceAssociationsStatusRequest(_a0 *ssm.DescribeInstanceAssociationsStatusInput) (*request.Request, *ssm.DescribeInstanceAssociationsStatusOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceAssociationsStatusInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeInstanceAssociationsStatusOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstanceAssociationsStatusInput) *ssm.DescribeInstanceAssociationsStatusOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeInstanceAssociationsStatusOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeInstanceAssociationsStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeInstanceAssociationsStatusWithContext(_a0 context.Context, _a1 *ssm.DescribeInstanceAssociationsStatusInput, _a2 ...request.Option) (*ssm.DescribeInstanceAssociationsStatusOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeInstanceAssociationsStatusOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstanceAssociationsStatusInput, ...request.Option) *ssm.DescribeInstanceAssociationsStatusOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstanceAssociationsStatusOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeInstanceAssociationsStatusInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstanceInformation provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstanceInformation(_a0 *ssm.DescribeInstanceInformationInput) (*ssm.DescribeInstanceInformationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeInstanceInformationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceInformationInput) *ssm.DescribeInstanceInformationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstanceInformationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstanceInformationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstanceInformationPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeInstanceInformationPages(_a0 *ssm.DescribeInstanceInformationInput, _a1 func(*ssm.DescribeInstanceInformationOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceInformationInput, func(*ssm.DescribeInstanceInformationOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstanceInformationPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeInstanceInformationPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstanceInformationInput, _a2 func(*ssm.DescribeInstanceInformationOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstanceInformationInput, func(*ssm.DescribeInstanceInformationOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstanceInformationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstanceInformationRequest(_a0 *ssm.DescribeInstanceInformationInput) (*request.Request, *ssm.DescribeInstanceInformationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstanceInformationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeInstanceInformationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstanceInformationInput) *ssm.DescribeInstanceInformationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeInstanceInformationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeInstanceInformationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeInstanceInformationWithContext(_a0 context.Context, _a1 *ssm.DescribeInstanceInformationInput, _a2 ...request.Option) (*ssm.DescribeInstanceInformationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeInstanceInformationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstanceInformationInput, ...request.Option) *ssm.DescribeInstanceInformationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstanceInformationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeInstanceInformationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatchStates provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstancePatchStates(_a0 *ssm.DescribeInstancePatchStatesInput) (*ssm.DescribeInstancePatchStatesOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeInstancePatchStatesOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesInput) *ssm.DescribeInstancePatchStatesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstancePatchStatesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchStatesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatchStatesForPatchGroup provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroup(_a0 *ssm.DescribeInstancePatchStatesForPatchGroupInput) (*ssm.DescribeInstancePatchStatesForPatchGroupOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeInstancePatchStatesForPatchGroupOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) *ssm.DescribeInstancePatchStatesForPatchGroupOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstancePatchStatesForPatchGroupOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatchStatesForPatchGroupPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroupPages(_a0 *ssm.DescribeInstancePatchStatesForPatchGroupInput, _a1 func(*ssm.DescribeInstancePatchStatesForPatchGroupOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput, func(*ssm.DescribeInstancePatchStatesForPatchGroupOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstancePatchStatesForPatchGroupPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroupPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchStatesForPatchGroupInput, _a2 func(*ssm.DescribeInstancePatchStatesForPatchGroupOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchStatesForPatchGroupInput, func(*ssm.DescribeInstancePatchStatesForPatchGroupOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstancePatchStatesForPatchGroupRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroupRequest(_a0 *ssm.DescribeInstancePatchStatesForPatchGroupInput) (*request.Request, *ssm.DescribeInstancePatchStatesForPatchGroupOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeInstancePatchStatesForPatchGroupOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchStatesForPatchGroupInput) *ssm.DescribeInstancePatchStatesForPatchGroupOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeInstancePatchStatesForPatchGroupOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatchStatesForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeInstancePatchStatesForPatchGroupWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchStatesForPatchGroupInput, _a2 ...request.Option) (*ssm.DescribeInstancePatchStatesForPatchGroupOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeInstancePatchStatesForPatchGroupOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchStatesForPatchGroupInput, ...request.Option) *ssm.DescribeInstancePatchStatesForPatchGroupOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstancePatchStatesForPatchGroupOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeInstancePatchStatesForPatchGroupInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatchStatesPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeInstancePatchStatesPages(_a0 *ssm.DescribeInstancePatchStatesInput, _a1 func(*ssm.DescribeInstancePatchStatesOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesInput, func(*ssm.DescribeInstancePatchStatesOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstancePatchStatesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeInstancePatchStatesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchStatesInput, _a2 func(*ssm.DescribeInstancePatchStatesOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchStatesInput, func(*ssm.DescribeInstancePatchStatesOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstancePatchStatesRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstancePatchStatesRequest(_a0 *ssm.DescribeInstancePatchStatesInput) (*request.Request, *ssm.DescribeInstancePatchStatesOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchStatesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeInstancePatchStatesOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchStatesInput) *ssm.DescribeInstancePatchStatesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeInstancePatchStatesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatchStatesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeInstancePatchStatesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchStatesInput, _a2 ...request.Option) (*ssm.DescribeInstancePatchStatesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeInstancePatchStatesOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchStatesInput, ...request.Option) *ssm.DescribeInstancePatchStatesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstancePatchStatesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeInstancePatchStatesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatches provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstancePatches(_a0 *ssm.DescribeInstancePatchesInput) (*ssm.DescribeInstancePatchesOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeInstancePatchesOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchesInput) *ssm.DescribeInstancePatchesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstancePatchesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatchesPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeInstancePatchesPages(_a0 *ssm.DescribeInstancePatchesInput, _a1 func(*ssm.DescribeInstancePatchesOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchesInput, func(*ssm.DescribeInstancePatchesOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstancePatchesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeInstancePatchesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchesInput, _a2 func(*ssm.DescribeInstancePatchesOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchesInput, func(*ssm.DescribeInstancePatchesOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInstancePatchesRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInstancePatchesRequest(_a0 *ssm.DescribeInstancePatchesInput) (*request.Request, *ssm.DescribeInstancePatchesOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInstancePatchesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeInstancePatchesOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInstancePatchesInput) *ssm.DescribeInstancePatchesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeInstancePatchesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeInstancePatchesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeInstancePatchesWithContext(_a0 context.Context, _a1 *ssm.DescribeInstancePatchesInput, _a2 ...request.Option) (*ssm.DescribeInstancePatchesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeInstancePatchesOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInstancePatchesInput, ...request.Option) *ssm.DescribeInstancePatchesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInstancePatchesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeInstancePatchesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInventoryDeletions provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInventoryDeletions(_a0 *ssm.DescribeInventoryDeletionsInput) (*ssm.DescribeInventoryDeletionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeInventoryDeletionsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInventoryDeletionsInput) *ssm.DescribeInventoryDeletionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInventoryDeletionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInventoryDeletionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeInventoryDeletionsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeInventoryDeletionsPages(_a0 *ssm.DescribeInventoryDeletionsInput, _a1 func(*ssm.DescribeInventoryDeletionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInventoryDeletionsInput, func(*ssm.DescribeInventoryDeletionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInventoryDeletionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeInventoryDeletionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeInventoryDeletionsInput, _a2 func(*ssm.DescribeInventoryDeletionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInventoryDeletionsInput, func(*ssm.DescribeInventoryDeletionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeInventoryDeletionsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeInventoryDeletionsRequest(_a0 *ssm.DescribeInventoryDeletionsInput) (*request.Request, *ssm.DescribeInventoryDeletionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeInventoryDeletionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeInventoryDeletionsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeInventoryDeletionsInput) *ssm.DescribeInventoryDeletionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeInventoryDeletionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeInventoryDeletionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeInventoryDeletionsWithContext(_a0 context.Context, _a1 *ssm.DescribeInventoryDeletionsInput, _a2 ...request.Option) (*ssm.DescribeInventoryDeletionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeInventoryDeletionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeInventoryDeletionsInput, ...request.Option) *ssm.DescribeInventoryDeletionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeInventoryDeletionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeInventoryDeletionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutionTaskInvocations provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocations(_a0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) (*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutionTaskInvocationsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsPages(_a0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, _a1 func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, _a2 func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowExecutionTaskInvocationsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsRequest(_a0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput) *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutionTaskInvocationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTaskInvocationsWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, ...request.Option) *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionTaskInvocationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutionTasks provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasks(_a0 *ssm.DescribeMaintenanceWindowExecutionTasksInput) (*ssm.DescribeMaintenanceWindowExecutionTasksOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeMaintenanceWindowExecutionTasksOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) *ssm.DescribeMaintenanceWindowExecutionTasksOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionTasksOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutionTasksPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasksPages(_a0 *ssm.DescribeMaintenanceWindowExecutionTasksInput, _a1 func(*ssm.DescribeMaintenanceWindowExecutionTasksOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput, func(*ssm.DescribeMaintenanceWindowExecutionTasksOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowExecutionTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasksPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionTasksInput, _a2 func(*ssm.DescribeMaintenanceWindowExecutionTasksOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTasksInput, func(*ssm.DescribeMaintenanceWindowExecutionTasksOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowExecutionTasksRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasksRequest(_a0 *ssm.DescribeMaintenanceWindowExecutionTasksInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionTasksOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeMaintenanceWindowExecutionTasksOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionTasksInput) *ssm.DescribeMaintenanceWindowExecutionTasksOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowExecutionTasksOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutionTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionTasksWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionTasksInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionTasksOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeMaintenanceWindowExecutionTasksOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTasksInput, ...request.Option) *ssm.DescribeMaintenanceWindowExecutionTasksOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionTasksOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionTasksInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutions provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutions(_a0 *ssm.DescribeMaintenanceWindowExecutionsInput) (*ssm.DescribeMaintenanceWindowExecutionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeMaintenanceWindowExecutionsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) *ssm.DescribeMaintenanceWindowExecutionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutionsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionsPages(_a0 *ssm.DescribeMaintenanceWindowExecutionsInput, _a1 func(*ssm.DescribeMaintenanceWindowExecutionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionsInput, func(*ssm.DescribeMaintenanceWindowExecutionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowExecutionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionsInput, _a2 func(*ssm.DescribeMaintenanceWindowExecutionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionsInput, func(*ssm.DescribeMaintenanceWindowExecutionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowExecutionsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionsRequest(_a0 *ssm.DescribeMaintenanceWindowExecutionsInput) (*request.Request, *ssm.DescribeMaintenanceWindowExecutionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeMaintenanceWindowExecutionsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowExecutionsInput) *ssm.DescribeMaintenanceWindowExecutionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowExecutionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowExecutionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeMaintenanceWindowExecutionsWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowExecutionsInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowExecutionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeMaintenanceWindowExecutionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionsInput, ...request.Option) *ssm.DescribeMaintenanceWindowExecutionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowExecutionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowExecutionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowSchedule provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowSchedule(_a0 *ssm.DescribeMaintenanceWindowScheduleInput) (*ssm.DescribeMaintenanceWindowScheduleOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeMaintenanceWindowScheduleOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowScheduleInput) *ssm.DescribeMaintenanceWindowScheduleOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowScheduleOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowScheduleInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowSchedulePages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeMaintenanceWindowSchedulePages(_a0 *ssm.DescribeMaintenanceWindowScheduleInput, _a1 func(*ssm.DescribeMaintenanceWindowScheduleOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowScheduleInput, func(*ssm.DescribeMaintenanceWindowScheduleOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowSchedulePagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeMaintenanceWindowSchedulePagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowScheduleInput, _a2 func(*ssm.DescribeMaintenanceWindowScheduleOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowScheduleInput, func(*ssm.DescribeMaintenanceWindowScheduleOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowScheduleRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowScheduleRequest(_a0 *ssm.DescribeMaintenanceWindowScheduleInput) (*request.Request, *ssm.DescribeMaintenanceWindowScheduleOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowScheduleInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeMaintenanceWindowScheduleOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowScheduleInput) *ssm.DescribeMaintenanceWindowScheduleOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowScheduleOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowScheduleWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeMaintenanceWindowScheduleWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowScheduleInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowScheduleOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeMaintenanceWindowScheduleOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowScheduleInput, ...request.Option) *ssm.DescribeMaintenanceWindowScheduleOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowScheduleOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowScheduleInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowTargets provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowTargets(_a0 *ssm.DescribeMaintenanceWindowTargetsInput) (*ssm.DescribeMaintenanceWindowTargetsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeMaintenanceWindowTargetsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTargetsInput) *ssm.DescribeMaintenanceWindowTargetsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTargetsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowTargetsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowTargetsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeMaintenanceWindowTargetsPages(_a0 *ssm.DescribeMaintenanceWindowTargetsInput, _a1 func(*ssm.DescribeMaintenanceWindowTargetsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTargetsInput, func(*ssm.DescribeMaintenanceWindowTargetsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowTargetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeMaintenanceWindowTargetsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowTargetsInput, _a2 func(*ssm.DescribeMaintenanceWindowTargetsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowTargetsInput, func(*ssm.DescribeMaintenanceWindowTargetsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowTargetsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowTargetsRequest(_a0 *ssm.DescribeMaintenanceWindowTargetsInput) (*request.Request, *ssm.DescribeMaintenanceWindowTargetsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTargetsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeMaintenanceWindowTargetsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowTargetsInput) *ssm.DescribeMaintenanceWindowTargetsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowTargetsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeMaintenanceWindowTargetsWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowTargetsInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowTargetsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeMaintenanceWindowTargetsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowTargetsInput, ...request.Option) *ssm.DescribeMaintenanceWindowTargetsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTargetsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowTargetsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowTasks provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowTasks(_a0 *ssm.DescribeMaintenanceWindowTasksInput) (*ssm.DescribeMaintenanceWindowTasksOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeMaintenanceWindowTasksOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTasksInput) *ssm.DescribeMaintenanceWindowTasksOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTasksOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowTasksInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowTasksPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeMaintenanceWindowTasksPages(_a0 *ssm.DescribeMaintenanceWindowTasksInput, _a1 func(*ssm.DescribeMaintenanceWindowTasksOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTasksInput, func(*ssm.DescribeMaintenanceWindowTasksOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeMaintenanceWindowTasksPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowTasksInput, _a2 func(*ssm.DescribeMaintenanceWindowTasksOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowTasksInput, func(*ssm.DescribeMaintenanceWindowTasksOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowTasksRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowTasksRequest(_a0 *ssm.DescribeMaintenanceWindowTasksInput) (*request.Request, *ssm.DescribeMaintenanceWindowTasksOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowTasksInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeMaintenanceWindowTasksOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowTasksInput) *ssm.DescribeMaintenanceWindowTasksOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowTasksOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeMaintenanceWindowTasksWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowTasksInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowTasksOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeMaintenanceWindowTasksOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowTasksInput, ...request.Option) *ssm.DescribeMaintenanceWindowTasksOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowTasksOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowTasksInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindows provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindows(_a0 *ssm.DescribeMaintenanceWindowsInput) (*ssm.DescribeMaintenanceWindowsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeMaintenanceWindowsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsInput) *ssm.DescribeMaintenanceWindowsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowsForTarget provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowsForTarget(_a0 *ssm.DescribeMaintenanceWindowsForTargetInput) (*ssm.DescribeMaintenanceWindowsForTargetOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeMaintenanceWindowsForTargetOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsForTargetInput) *ssm.DescribeMaintenanceWindowsForTargetOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowsForTargetOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowsForTargetInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowsForTargetPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeMaintenanceWindowsForTargetPages(_a0 *ssm.DescribeMaintenanceWindowsForTargetInput, _a1 func(*ssm.DescribeMaintenanceWindowsForTargetOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsForTargetInput, func(*ssm.DescribeMaintenanceWindowsForTargetOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowsForTargetPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeMaintenanceWindowsForTargetPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowsForTargetInput, _a2 func(*ssm.DescribeMaintenanceWindowsForTargetOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsForTargetInput, func(*ssm.DescribeMaintenanceWindowsForTargetOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowsForTargetRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowsForTargetRequest(_a0 *ssm.DescribeMaintenanceWindowsForTargetInput) (*request.Request, *ssm.DescribeMaintenanceWindowsForTargetOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsForTargetInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeMaintenanceWindowsForTargetOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowsForTargetInput) *ssm.DescribeMaintenanceWindowsForTargetOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowsForTargetOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowsForTargetWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeMaintenanceWindowsForTargetWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowsForTargetInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowsForTargetOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeMaintenanceWindowsForTargetOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsForTargetInput, ...request.Option) *ssm.DescribeMaintenanceWindowsForTargetOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowsForTargetOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowsForTargetInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeMaintenanceWindowsPages(_a0 *ssm.DescribeMaintenanceWindowsInput, _a1 func(*ssm.DescribeMaintenanceWindowsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsInput, func(*ssm.DescribeMaintenanceWindowsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeMaintenanceWindowsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowsInput, _a2 func(*ssm.DescribeMaintenanceWindowsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsInput, func(*ssm.DescribeMaintenanceWindowsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeMaintenanceWindowsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeMaintenanceWindowsRequest(_a0 *ssm.DescribeMaintenanceWindowsInput) (*request.Request, *ssm.DescribeMaintenanceWindowsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeMaintenanceWindowsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeMaintenanceWindowsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeMaintenanceWindowsInput) *ssm.DescribeMaintenanceWindowsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeMaintenanceWindowsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeMaintenanceWindowsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeMaintenanceWindowsWithContext(_a0 context.Context, _a1 *ssm.DescribeMaintenanceWindowsInput, _a2 ...request.Option) (*ssm.DescribeMaintenanceWindowsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeMaintenanceWindowsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeMaintenanceWindowsInput, ...request.Option) *ssm.DescribeMaintenanceWindowsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeMaintenanceWindowsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeMaintenanceWindowsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeOpsItems provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeOpsItems(_a0 *ssm.DescribeOpsItemsInput) (*ssm.DescribeOpsItemsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeOpsItemsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeOpsItemsInput) *ssm.DescribeOpsItemsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeOpsItemsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeOpsItemsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeOpsItemsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeOpsItemsPages(_a0 *ssm.DescribeOpsItemsInput, _a1 func(*ssm.DescribeOpsItemsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeOpsItemsInput, func(*ssm.DescribeOpsItemsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeOpsItemsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeOpsItemsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeOpsItemsInput, _a2 func(*ssm.DescribeOpsItemsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeOpsItemsInput, func(*ssm.DescribeOpsItemsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeOpsItemsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeOpsItemsRequest(_a0 *ssm.DescribeOpsItemsInput) (*request.Request, *ssm.DescribeOpsItemsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeOpsItemsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeOpsItemsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeOpsItemsInput) *ssm.DescribeOpsItemsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeOpsItemsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeOpsItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeOpsItemsWithContext(_a0 context.Context, _a1 *ssm.DescribeOpsItemsInput, _a2 ...request.Option) (*ssm.DescribeOpsItemsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeOpsItemsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeOpsItemsInput, ...request.Option) *ssm.DescribeOpsItemsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeOpsItemsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeOpsItemsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeParameters provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeParameters(_a0 *ssm.DescribeParametersInput) (*ssm.DescribeParametersOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeParametersOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeParametersInput) *ssm.DescribeParametersOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeParametersOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeParametersInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeParametersPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeParametersPages(_a0 *ssm.DescribeParametersInput, _a1 func(*ssm.DescribeParametersOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeParametersInput, func(*ssm.DescribeParametersOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeParametersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeParametersPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeParametersInput, _a2 func(*ssm.DescribeParametersOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeParametersInput, func(*ssm.DescribeParametersOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeParametersRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeParametersRequest(_a0 *ssm.DescribeParametersInput) (*request.Request, *ssm.DescribeParametersOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeParametersInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeParametersOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeParametersInput) *ssm.DescribeParametersOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeParametersOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeParametersWithContext(_a0 context.Context, _a1 *ssm.DescribeParametersInput, _a2 ...request.Option) (*ssm.DescribeParametersOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeParametersOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeParametersInput, ...request.Option) *ssm.DescribeParametersOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeParametersOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeParametersInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribePatchBaselines provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribePatchBaselines(_a0 *ssm.DescribePatchBaselinesInput) (*ssm.DescribePatchBaselinesOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribePatchBaselinesOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchBaselinesInput) *ssm.DescribePatchBaselinesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribePatchBaselinesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchBaselinesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribePatchBaselinesPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribePatchBaselinesPages(_a0 *ssm.DescribePatchBaselinesInput, _a1 func(*ssm.DescribePatchBaselinesOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchBaselinesInput, func(*ssm.DescribePatchBaselinesOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribePatchBaselinesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribePatchBaselinesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchBaselinesInput, _a2 func(*ssm.DescribePatchBaselinesOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchBaselinesInput, func(*ssm.DescribePatchBaselinesOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribePatchBaselinesRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribePatchBaselinesRequest(_a0 *ssm.DescribePatchBaselinesInput) (*request.Request, *ssm.DescribePatchBaselinesOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchBaselinesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribePatchBaselinesOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchBaselinesInput) *ssm.DescribePatchBaselinesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribePatchBaselinesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribePatchBaselinesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribePatchBaselinesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchBaselinesInput, _a2 ...request.Option) (*ssm.DescribePatchBaselinesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribePatchBaselinesOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchBaselinesInput, ...request.Option) *ssm.DescribePatchBaselinesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribePatchBaselinesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribePatchBaselinesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribePatchGroupState provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribePatchGroupState(_a0 *ssm.DescribePatchGroupStateInput) (*ssm.DescribePatchGroupStateOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribePatchGroupStateOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupStateInput) *ssm.DescribePatchGroupStateOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribePatchGroupStateOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchGroupStateInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribePatchGroupStateRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribePatchGroupStateRequest(_a0 *ssm.DescribePatchGroupStateInput) (*request.Request, *ssm.DescribePatchGroupStateOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupStateInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribePatchGroupStateOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchGroupStateInput) *ssm.DescribePatchGroupStateOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribePatchGroupStateOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribePatchGroupStateWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribePatchGroupStateWithContext(_a0 context.Context, _a1 *ssm.DescribePatchGroupStateInput, _a2 ...request.Option) (*ssm.DescribePatchGroupStateOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribePatchGroupStateOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchGroupStateInput, ...request.Option) *ssm.DescribePatchGroupStateOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribePatchGroupStateOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribePatchGroupStateInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribePatchGroups provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribePatchGroups(_a0 *ssm.DescribePatchGroupsInput) (*ssm.DescribePatchGroupsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribePatchGroupsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupsInput) *ssm.DescribePatchGroupsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribePatchGroupsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchGroupsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribePatchGroupsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribePatchGroupsPages(_a0 *ssm.DescribePatchGroupsInput, _a1 func(*ssm.DescribePatchGroupsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupsInput, func(*ssm.DescribePatchGroupsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribePatchGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribePatchGroupsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchGroupsInput, _a2 func(*ssm.DescribePatchGroupsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchGroupsInput, func(*ssm.DescribePatchGroupsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribePatchGroupsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribePatchGroupsRequest(_a0 *ssm.DescribePatchGroupsInput) (*request.Request, *ssm.DescribePatchGroupsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchGroupsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribePatchGroupsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchGroupsInput) *ssm.DescribePatchGroupsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribePatchGroupsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribePatchGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribePatchGroupsWithContext(_a0 context.Context, _a1 *ssm.DescribePatchGroupsInput, _a2 ...request.Option) (*ssm.DescribePatchGroupsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribePatchGroupsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchGroupsInput, ...request.Option) *ssm.DescribePatchGroupsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribePatchGroupsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribePatchGroupsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribePatchProperties provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribePatchProperties(_a0 *ssm.DescribePatchPropertiesInput) (*ssm.DescribePatchPropertiesOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribePatchPropertiesOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchPropertiesInput) *ssm.DescribePatchPropertiesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribePatchPropertiesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchPropertiesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribePatchPropertiesPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribePatchPropertiesPages(_a0 *ssm.DescribePatchPropertiesInput, _a1 func(*ssm.DescribePatchPropertiesOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchPropertiesInput, func(*ssm.DescribePatchPropertiesOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribePatchPropertiesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribePatchPropertiesPagesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchPropertiesInput, _a2 func(*ssm.DescribePatchPropertiesOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchPropertiesInput, func(*ssm.DescribePatchPropertiesOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribePatchPropertiesRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribePatchPropertiesRequest(_a0 *ssm.DescribePatchPropertiesInput) (*request.Request, *ssm.DescribePatchPropertiesOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribePatchPropertiesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribePatchPropertiesOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribePatchPropertiesInput) *ssm.DescribePatchPropertiesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribePatchPropertiesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribePatchPropertiesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribePatchPropertiesWithContext(_a0 context.Context, _a1 *ssm.DescribePatchPropertiesInput, _a2 ...request.Option) (*ssm.DescribePatchPropertiesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribePatchPropertiesOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribePatchPropertiesInput, ...request.Option) *ssm.DescribePatchPropertiesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribePatchPropertiesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribePatchPropertiesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeSessions provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeSessions(_a0 *ssm.DescribeSessionsInput) (*ssm.DescribeSessionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DescribeSessionsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeSessionsInput) *ssm.DescribeSessionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeSessionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeSessionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DescribeSessionsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) DescribeSessionsPages(_a0 *ssm.DescribeSessionsInput, _a1 func(*ssm.DescribeSessionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeSessionsInput, func(*ssm.DescribeSessionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeSessionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) DescribeSessionsPagesWithContext(_a0 context.Context, _a1 *ssm.DescribeSessionsInput, _a2 func(*ssm.DescribeSessionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeSessionsInput, func(*ssm.DescribeSessionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// DescribeSessionsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DescribeSessionsRequest(_a0 *ssm.DescribeSessionsInput) (*request.Request, *ssm.DescribeSessionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DescribeSessionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DescribeSessionsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DescribeSessionsInput) *ssm.DescribeSessionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DescribeSessionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DescribeSessionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DescribeSessionsWithContext(_a0 context.Context, _a1 *ssm.DescribeSessionsInput, _a2 ...request.Option) (*ssm.DescribeSessionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DescribeSessionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DescribeSessionsInput, ...request.Option) *ssm.DescribeSessionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DescribeSessionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DescribeSessionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DisassociateOpsItemRelatedItem provides a mock function with given fields: _a0
-func (_m *SSMAPI) DisassociateOpsItemRelatedItem(_a0 *ssm.DisassociateOpsItemRelatedItemInput) (*ssm.DisassociateOpsItemRelatedItemOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.DisassociateOpsItemRelatedItemOutput
-	if rf, ok := ret.Get(0).(func(*ssm.DisassociateOpsItemRelatedItemInput) *ssm.DisassociateOpsItemRelatedItemOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DisassociateOpsItemRelatedItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.DisassociateOpsItemRelatedItemInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DisassociateOpsItemRelatedItemRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) DisassociateOpsItemRelatedItemRequest(_a0 *ssm.DisassociateOpsItemRelatedItemInput) (*request.Request, *ssm.DisassociateOpsItemRelatedItemOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.DisassociateOpsItemRelatedItemInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.DisassociateOpsItemRelatedItemOutput
-	if rf, ok := ret.Get(1).(func(*ssm.DisassociateOpsItemRelatedItemInput) *ssm.DisassociateOpsItemRelatedItemOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.DisassociateOpsItemRelatedItemOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DisassociateOpsItemRelatedItemWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) DisassociateOpsItemRelatedItemWithContext(_a0 context.Context, _a1 *ssm.DisassociateOpsItemRelatedItemInput, _a2 ...request.Option) (*ssm.DisassociateOpsItemRelatedItemOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.DisassociateOpsItemRelatedItemOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.DisassociateOpsItemRelatedItemInput, ...request.Option) *ssm.DisassociateOpsItemRelatedItemOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.DisassociateOpsItemRelatedItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.DisassociateOpsItemRelatedItemInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetAutomationExecution provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetAutomationExecution(_a0 *ssm.GetAutomationExecutionInput) (*ssm.GetAutomationExecutionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetAutomationExecutionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetAutomationExecutionInput) *ssm.GetAutomationExecutionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetAutomationExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetAutomationExecutionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetAutomationExecutionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetAutomationExecutionRequest(_a0 *ssm.GetAutomationExecutionInput) (*request.Request, *ssm.GetAutomationExecutionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetAutomationExecutionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetAutomationExecutionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetAutomationExecutionInput) *ssm.GetAutomationExecutionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetAutomationExecutionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetAutomationExecutionWithContext(_a0 context.Context, _a1 *ssm.GetAutomationExecutionInput, _a2 ...request.Option) (*ssm.GetAutomationExecutionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetAutomationExecutionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetAutomationExecutionInput, ...request.Option) *ssm.GetAutomationExecutionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetAutomationExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetAutomationExecutionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetCalendarState provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetCalendarState(_a0 *ssm.GetCalendarStateInput) (*ssm.GetCalendarStateOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetCalendarStateOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetCalendarStateInput) *ssm.GetCalendarStateOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetCalendarStateOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetCalendarStateInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetCalendarStateRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetCalendarStateRequest(_a0 *ssm.GetCalendarStateInput) (*request.Request, *ssm.GetCalendarStateOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetCalendarStateInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetCalendarStateOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetCalendarStateInput) *ssm.GetCalendarStateOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetCalendarStateOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetCalendarStateWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetCalendarStateWithContext(_a0 context.Context, _a1 *ssm.GetCalendarStateInput, _a2 ...request.Option) (*ssm.GetCalendarStateOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetCalendarStateOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCalendarStateInput, ...request.Option) *ssm.GetCalendarStateOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetCalendarStateOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetCalendarStateInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetCommandInvocation provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetCommandInvocation(_a0 *ssm.GetCommandInvocationInput) (*ssm.GetCommandInvocationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetCommandInvocationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetCommandInvocationInput) *ssm.GetCommandInvocationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetCommandInvocationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetCommandInvocationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetCommandInvocationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetCommandInvocationRequest(_a0 *ssm.GetCommandInvocationInput) (*request.Request, *ssm.GetCommandInvocationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetCommandInvocationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetCommandInvocationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetCommandInvocationInput) *ssm.GetCommandInvocationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetCommandInvocationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetCommandInvocationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetCommandInvocationWithContext(_a0 context.Context, _a1 *ssm.GetCommandInvocationInput, _a2 ...request.Option) (*ssm.GetCommandInvocationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetCommandInvocationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCommandInvocationInput, ...request.Option) *ssm.GetCommandInvocationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetCommandInvocationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetCommandInvocationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetConnectionStatus provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetConnectionStatus(_a0 *ssm.GetConnectionStatusInput) (*ssm.GetConnectionStatusOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetConnectionStatusOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetConnectionStatusInput) *ssm.GetConnectionStatusOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetConnectionStatusOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetConnectionStatusInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetConnectionStatusRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetConnectionStatusRequest(_a0 *ssm.GetConnectionStatusInput) (*request.Request, *ssm.GetConnectionStatusOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetConnectionStatusInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetConnectionStatusOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetConnectionStatusInput) *ssm.GetConnectionStatusOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetConnectionStatusOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetConnectionStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetConnectionStatusWithContext(_a0 context.Context, _a1 *ssm.GetConnectionStatusInput, _a2 ...request.Option) (*ssm.GetConnectionStatusOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetConnectionStatusOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetConnectionStatusInput, ...request.Option) *ssm.GetConnectionStatusOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetConnectionStatusOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetConnectionStatusInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetDefaultPatchBaseline provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetDefaultPatchBaseline(_a0 *ssm.GetDefaultPatchBaselineInput) (*ssm.GetDefaultPatchBaselineOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetDefaultPatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetDefaultPatchBaselineInput) *ssm.GetDefaultPatchBaselineOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetDefaultPatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetDefaultPatchBaselineInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetDefaultPatchBaselineRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetDefaultPatchBaselineRequest(_a0 *ssm.GetDefaultPatchBaselineInput) (*request.Request, *ssm.GetDefaultPatchBaselineOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetDefaultPatchBaselineInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetDefaultPatchBaselineOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetDefaultPatchBaselineInput) *ssm.GetDefaultPatchBaselineOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetDefaultPatchBaselineOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetDefaultPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetDefaultPatchBaselineWithContext(_a0 context.Context, _a1 *ssm.GetDefaultPatchBaselineInput, _a2 ...request.Option) (*ssm.GetDefaultPatchBaselineOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetDefaultPatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetDefaultPatchBaselineInput, ...request.Option) *ssm.GetDefaultPatchBaselineOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetDefaultPatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetDefaultPatchBaselineInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetDeployablePatchSnapshotForInstance provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetDeployablePatchSnapshotForInstance(_a0 *ssm.GetDeployablePatchSnapshotForInstanceInput) (*ssm.GetDeployablePatchSnapshotForInstanceOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetDeployablePatchSnapshotForInstanceOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetDeployablePatchSnapshotForInstanceInput) *ssm.GetDeployablePatchSnapshotForInstanceOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetDeployablePatchSnapshotForInstanceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetDeployablePatchSnapshotForInstanceInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetDeployablePatchSnapshotForInstanceRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetDeployablePatchSnapshotForInstanceRequest(_a0 *ssm.GetDeployablePatchSnapshotForInstanceInput) (*request.Request, *ssm.GetDeployablePatchSnapshotForInstanceOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetDeployablePatchSnapshotForInstanceInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetDeployablePatchSnapshotForInstanceOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetDeployablePatchSnapshotForInstanceInput) *ssm.GetDeployablePatchSnapshotForInstanceOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetDeployablePatchSnapshotForInstanceOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetDeployablePatchSnapshotForInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetDeployablePatchSnapshotForInstanceWithContext(_a0 context.Context, _a1 *ssm.GetDeployablePatchSnapshotForInstanceInput, _a2 ...request.Option) (*ssm.GetDeployablePatchSnapshotForInstanceOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetDeployablePatchSnapshotForInstanceOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetDeployablePatchSnapshotForInstanceInput, ...request.Option) *ssm.GetDeployablePatchSnapshotForInstanceOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetDeployablePatchSnapshotForInstanceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetDeployablePatchSnapshotForInstanceInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetDocument provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetDocument(_a0 *ssm.GetDocumentInput) (*ssm.GetDocumentOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetDocumentOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetDocumentInput) *ssm.GetDocumentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetDocumentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetDocumentRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetDocumentRequest(_a0 *ssm.GetDocumentInput) (*request.Request, *ssm.GetDocumentOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetDocumentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetDocumentOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetDocumentInput) *ssm.GetDocumentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetDocumentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetDocumentWithContext(_a0 context.Context, _a1 *ssm.GetDocumentInput, _a2 ...request.Option) (*ssm.GetDocumentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetDocumentOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetDocumentInput, ...request.Option) *ssm.GetDocumentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetDocumentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetInventory provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetInventory(_a0 *ssm.GetInventoryInput) (*ssm.GetInventoryOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetInventoryOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetInventoryInput) *ssm.GetInventoryOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetInventoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetInventoryInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetInventoryPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) GetInventoryPages(_a0 *ssm.GetInventoryInput, _a1 func(*ssm.GetInventoryOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.GetInventoryInput, func(*ssm.GetInventoryOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetInventoryPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) GetInventoryPagesWithContext(_a0 context.Context, _a1 *ssm.GetInventoryInput, _a2 func(*ssm.GetInventoryOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetInventoryInput, func(*ssm.GetInventoryOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetInventoryRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetInventoryRequest(_a0 *ssm.GetInventoryInput) (*request.Request, *ssm.GetInventoryOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetInventoryInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetInventoryOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetInventoryInput) *ssm.GetInventoryOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetInventoryOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetInventorySchema provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetInventorySchema(_a0 *ssm.GetInventorySchemaInput) (*ssm.GetInventorySchemaOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetInventorySchemaOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetInventorySchemaInput) *ssm.GetInventorySchemaOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetInventorySchemaOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetInventorySchemaInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetInventorySchemaPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) GetInventorySchemaPages(_a0 *ssm.GetInventorySchemaInput, _a1 func(*ssm.GetInventorySchemaOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.GetInventorySchemaInput, func(*ssm.GetInventorySchemaOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetInventorySchemaPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) GetInventorySchemaPagesWithContext(_a0 context.Context, _a1 *ssm.GetInventorySchemaInput, _a2 func(*ssm.GetInventorySchemaOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetInventorySchemaInput, func(*ssm.GetInventorySchemaOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetInventorySchemaRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetInventorySchemaRequest(_a0 *ssm.GetInventorySchemaInput) (*request.Request, *ssm.GetInventorySchemaOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetInventorySchemaInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetInventorySchemaOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetInventorySchemaInput) *ssm.GetInventorySchemaOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetInventorySchemaOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetInventorySchemaWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetInventorySchemaWithContext(_a0 context.Context, _a1 *ssm.GetInventorySchemaInput, _a2 ...request.Option) (*ssm.GetInventorySchemaOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetInventorySchemaOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetInventorySchemaInput, ...request.Option) *ssm.GetInventorySchemaOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetInventorySchemaOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetInventorySchemaInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetInventoryWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetInventoryWithContext(_a0 context.Context, _a1 *ssm.GetInventoryInput, _a2 ...request.Option) (*ssm.GetInventoryOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetInventoryOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetInventoryInput, ...request.Option) *ssm.GetInventoryOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetInventoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetInventoryInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindow provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindow(_a0 *ssm.GetMaintenanceWindowInput) (*ssm.GetMaintenanceWindowOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowInput) *ssm.GetMaintenanceWindowOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecution provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowExecution(_a0 *ssm.GetMaintenanceWindowExecutionInput) (*ssm.GetMaintenanceWindowExecutionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetMaintenanceWindowExecutionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionInput) *ssm.GetMaintenanceWindowExecutionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecutionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowExecutionRequest(_a0 *ssm.GetMaintenanceWindowExecutionInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetMaintenanceWindowExecutionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionInput) *ssm.GetMaintenanceWindowExecutionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowExecutionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecutionTask provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowExecutionTask(_a0 *ssm.GetMaintenanceWindowExecutionTaskInput) (*ssm.GetMaintenanceWindowExecutionTaskOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetMaintenanceWindowExecutionTaskOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) *ssm.GetMaintenanceWindowExecutionTaskOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionTaskOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecutionTaskInvocation provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskInvocation(_a0 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput) (*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInvocationInput) *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionTaskInvocationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecutionTaskInvocationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskInvocationRequest(_a0 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInvocationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionTaskInvocationInput) *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecutionTaskInvocationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskInvocationWithContext(_a0 context.Context, _a1 *ssm.GetMaintenanceWindowExecutionTaskInvocationInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowExecutionTaskInvocationInput, ...request.Option) *ssm.GetMaintenanceWindowExecutionTaskInvocationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionTaskInvocationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetMaintenanceWindowExecutionTaskInvocationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecutionTaskRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskRequest(_a0 *ssm.GetMaintenanceWindowExecutionTaskInput) (*request.Request, *ssm.GetMaintenanceWindowExecutionTaskOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetMaintenanceWindowExecutionTaskOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowExecutionTaskInput) *ssm.GetMaintenanceWindowExecutionTaskOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowExecutionTaskOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecutionTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetMaintenanceWindowExecutionTaskWithContext(_a0 context.Context, _a1 *ssm.GetMaintenanceWindowExecutionTaskInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionTaskOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetMaintenanceWindowExecutionTaskOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowExecutionTaskInput, ...request.Option) *ssm.GetMaintenanceWindowExecutionTaskOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionTaskOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetMaintenanceWindowExecutionTaskInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetMaintenanceWindowExecutionWithContext(_a0 context.Context, _a1 *ssm.GetMaintenanceWindowExecutionInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowExecutionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetMaintenanceWindowExecutionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowExecutionInput, ...request.Option) *ssm.GetMaintenanceWindowExecutionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetMaintenanceWindowExecutionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowRequest(_a0 *ssm.GetMaintenanceWindowInput) (*request.Request, *ssm.GetMaintenanceWindowOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetMaintenanceWindowOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowInput) *ssm.GetMaintenanceWindowOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowTask provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowTask(_a0 *ssm.GetMaintenanceWindowTaskInput) (*ssm.GetMaintenanceWindowTaskOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetMaintenanceWindowTaskOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowTaskInput) *ssm.GetMaintenanceWindowTaskOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowTaskOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowTaskInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowTaskRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetMaintenanceWindowTaskRequest(_a0 *ssm.GetMaintenanceWindowTaskInput) (*request.Request, *ssm.GetMaintenanceWindowTaskOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetMaintenanceWindowTaskInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetMaintenanceWindowTaskOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetMaintenanceWindowTaskInput) *ssm.GetMaintenanceWindowTaskOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetMaintenanceWindowTaskOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetMaintenanceWindowTaskWithContext(_a0 context.Context, _a1 *ssm.GetMaintenanceWindowTaskInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowTaskOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetMaintenanceWindowTaskOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowTaskInput, ...request.Option) *ssm.GetMaintenanceWindowTaskOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowTaskOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetMaintenanceWindowTaskInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetMaintenanceWindowWithContext(_a0 context.Context, _a1 *ssm.GetMaintenanceWindowInput, _a2 ...request.Option) (*ssm.GetMaintenanceWindowOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetMaintenanceWindowInput, ...request.Option) *ssm.GetMaintenanceWindowOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetMaintenanceWindowInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetOpsItem provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetOpsItem(_a0 *ssm.GetOpsItemInput) (*ssm.GetOpsItemOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetOpsItemOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetOpsItemInput) *ssm.GetOpsItemOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetOpsItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetOpsItemInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetOpsItemRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetOpsItemRequest(_a0 *ssm.GetOpsItemInput) (*request.Request, *ssm.GetOpsItemOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetOpsItemInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetOpsItemOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetOpsItemInput) *ssm.GetOpsItemOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetOpsItemOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetOpsItemWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetOpsItemWithContext(_a0 context.Context, _a1 *ssm.GetOpsItemInput, _a2 ...request.Option) (*ssm.GetOpsItemOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetOpsItemOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsItemInput, ...request.Option) *ssm.GetOpsItemOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetOpsItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetOpsItemInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetOpsMetadata provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetOpsMetadata(_a0 *ssm.GetOpsMetadataInput) (*ssm.GetOpsMetadataOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetOpsMetadataInput) *ssm.GetOpsMetadataOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetOpsMetadataInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetOpsMetadataRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetOpsMetadataRequest(_a0 *ssm.GetOpsMetadataInput) (*request.Request, *ssm.GetOpsMetadataOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetOpsMetadataInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetOpsMetadataOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetOpsMetadataInput) *ssm.GetOpsMetadataOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetOpsMetadataOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.GetOpsMetadataInput, _a2 ...request.Option) (*ssm.GetOpsMetadataOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsMetadataInput, ...request.Option) *ssm.GetOpsMetadataOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetOpsMetadataInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetOpsSummary provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetOpsSummary(_a0 *ssm.GetOpsSummaryInput) (*ssm.GetOpsSummaryOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetOpsSummaryOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetOpsSummaryInput) *ssm.GetOpsSummaryOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetOpsSummaryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetOpsSummaryInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetOpsSummaryPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) GetOpsSummaryPages(_a0 *ssm.GetOpsSummaryInput, _a1 func(*ssm.GetOpsSummaryOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.GetOpsSummaryInput, func(*ssm.GetOpsSummaryOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetOpsSummaryPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) GetOpsSummaryPagesWithContext(_a0 context.Context, _a1 *ssm.GetOpsSummaryInput, _a2 func(*ssm.GetOpsSummaryOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsSummaryInput, func(*ssm.GetOpsSummaryOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetOpsSummaryRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetOpsSummaryRequest(_a0 *ssm.GetOpsSummaryInput) (*request.Request, *ssm.GetOpsSummaryOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetOpsSummaryInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetOpsSummaryOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetOpsSummaryInput) *ssm.GetOpsSummaryOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetOpsSummaryOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetOpsSummaryWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetOpsSummaryWithContext(_a0 context.Context, _a1 *ssm.GetOpsSummaryInput, _a2 ...request.Option) (*ssm.GetOpsSummaryOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetOpsSummaryOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetOpsSummaryInput, ...request.Option) *ssm.GetOpsSummaryOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetOpsSummaryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetOpsSummaryInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetParameter provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetParameter(_a0 *ssm.GetParameterInput) (*ssm.GetParameterOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetParameterOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetParameterInput) *ssm.GetParameterOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetParameterOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetParameterInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetParameterHistory provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetParameterHistory(_a0 *ssm.GetParameterHistoryInput) (*ssm.GetParameterHistoryOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetParameterHistoryOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetParameterHistoryInput) *ssm.GetParameterHistoryOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetParameterHistoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetParameterHistoryInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetParameterHistoryPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) GetParameterHistoryPages(_a0 *ssm.GetParameterHistoryInput, _a1 func(*ssm.GetParameterHistoryOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.GetParameterHistoryInput, func(*ssm.GetParameterHistoryOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetParameterHistoryPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) GetParameterHistoryPagesWithContext(_a0 context.Context, _a1 *ssm.GetParameterHistoryInput, _a2 func(*ssm.GetParameterHistoryOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParameterHistoryInput, func(*ssm.GetParameterHistoryOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetParameterHistoryRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetParameterHistoryRequest(_a0 *ssm.GetParameterHistoryInput) (*request.Request, *ssm.GetParameterHistoryOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetParameterHistoryInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetParameterHistoryOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetParameterHistoryInput) *ssm.GetParameterHistoryOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetParameterHistoryOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetParameterHistoryWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetParameterHistoryWithContext(_a0 context.Context, _a1 *ssm.GetParameterHistoryInput, _a2 ...request.Option) (*ssm.GetParameterHistoryOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetParameterHistoryOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParameterHistoryInput, ...request.Option) *ssm.GetParameterHistoryOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetParameterHistoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetParameterHistoryInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetParameterRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetParameterRequest(_a0 *ssm.GetParameterInput) (*request.Request, *ssm.GetParameterOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetParameterInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetParameterOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetParameterInput) *ssm.GetParameterOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetParameterOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetParameterWithContext(_a0 context.Context, _a1 *ssm.GetParameterInput, _a2 ...request.Option) (*ssm.GetParameterOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetParameterOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParameterInput, ...request.Option) *ssm.GetParameterOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetParameterOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetParameterInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetParameters provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetParameters(_a0 *ssm.GetParametersInput) (*ssm.GetParametersOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetParametersOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetParametersInput) *ssm.GetParametersOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetParametersOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetParametersInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetParametersByPath provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetParametersByPath(_a0 *ssm.GetParametersByPathInput) (*ssm.GetParametersByPathOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetParametersByPathOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetParametersByPathInput) *ssm.GetParametersByPathOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetParametersByPathOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetParametersByPathInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetParametersByPathPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) GetParametersByPathPages(_a0 *ssm.GetParametersByPathInput, _a1 func(*ssm.GetParametersByPathOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.GetParametersByPathInput, func(*ssm.GetParametersByPathOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetParametersByPathPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) GetParametersByPathPagesWithContext(_a0 context.Context, _a1 *ssm.GetParametersByPathInput, _a2 func(*ssm.GetParametersByPathOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParametersByPathInput, func(*ssm.GetParametersByPathOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetParametersByPathRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetParametersByPathRequest(_a0 *ssm.GetParametersByPathInput) (*request.Request, *ssm.GetParametersByPathOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetParametersByPathInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetParametersByPathOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetParametersByPathInput) *ssm.GetParametersByPathOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetParametersByPathOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetParametersByPathWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetParametersByPathWithContext(_a0 context.Context, _a1 *ssm.GetParametersByPathInput, _a2 ...request.Option) (*ssm.GetParametersByPathOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetParametersByPathOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParametersByPathInput, ...request.Option) *ssm.GetParametersByPathOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetParametersByPathOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetParametersByPathInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetParametersRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetParametersRequest(_a0 *ssm.GetParametersInput) (*request.Request, *ssm.GetParametersOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetParametersInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetParametersOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetParametersInput) *ssm.GetParametersOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetParametersOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetParametersWithContext(_a0 context.Context, _a1 *ssm.GetParametersInput, _a2 ...request.Option) (*ssm.GetParametersOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetParametersOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetParametersInput, ...request.Option) *ssm.GetParametersOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetParametersOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetParametersInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetPatchBaseline provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetPatchBaseline(_a0 *ssm.GetPatchBaselineInput) (*ssm.GetPatchBaselineOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetPatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineInput) *ssm.GetPatchBaselineOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetPatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetPatchBaselineInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetPatchBaselineForPatchGroup provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetPatchBaselineForPatchGroup(_a0 *ssm.GetPatchBaselineForPatchGroupInput) (*ssm.GetPatchBaselineForPatchGroupOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineForPatchGroupInput) *ssm.GetPatchBaselineForPatchGroupOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetPatchBaselineForPatchGroupInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetPatchBaselineForPatchGroupRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetPatchBaselineForPatchGroupRequest(_a0 *ssm.GetPatchBaselineForPatchGroupInput) (*request.Request, *ssm.GetPatchBaselineForPatchGroupOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineForPatchGroupInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetPatchBaselineForPatchGroupInput) *ssm.GetPatchBaselineForPatchGroupOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetPatchBaselineForPatchGroupWithContext(_a0 context.Context, _a1 *ssm.GetPatchBaselineForPatchGroupInput, _a2 ...request.Option) (*ssm.GetPatchBaselineForPatchGroupOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetPatchBaselineForPatchGroupInput, ...request.Option) *ssm.GetPatchBaselineForPatchGroupOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetPatchBaselineForPatchGroupInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetPatchBaselineRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetPatchBaselineRequest(_a0 *ssm.GetPatchBaselineInput) (*request.Request, *ssm.GetPatchBaselineOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetPatchBaselineInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetPatchBaselineOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetPatchBaselineInput) *ssm.GetPatchBaselineOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetPatchBaselineOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetPatchBaselineWithContext(_a0 context.Context, _a1 *ssm.GetPatchBaselineInput, _a2 ...request.Option) (*ssm.GetPatchBaselineOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetPatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetPatchBaselineInput, ...request.Option) *ssm.GetPatchBaselineOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetPatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetPatchBaselineInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetServiceSetting provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetServiceSetting(_a0 *ssm.GetServiceSettingInput) (*ssm.GetServiceSettingOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.GetServiceSettingOutput
-	if rf, ok := ret.Get(0).(func(*ssm.GetServiceSettingInput) *ssm.GetServiceSettingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetServiceSettingOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.GetServiceSettingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetServiceSettingRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) GetServiceSettingRequest(_a0 *ssm.GetServiceSettingInput) (*request.Request, *ssm.GetServiceSettingOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.GetServiceSettingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.GetServiceSettingOutput
-	if rf, ok := ret.Get(1).(func(*ssm.GetServiceSettingInput) *ssm.GetServiceSettingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.GetServiceSettingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetServiceSettingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) GetServiceSettingWithContext(_a0 context.Context, _a1 *ssm.GetServiceSettingInput, _a2 ...request.Option) (*ssm.GetServiceSettingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.GetServiceSettingOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetServiceSettingInput, ...request.Option) *ssm.GetServiceSettingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.GetServiceSettingOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.GetServiceSettingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// LabelParameterVersion provides a mock function with given fields: _a0
-func (_m *SSMAPI) LabelParameterVersion(_a0 *ssm.LabelParameterVersionInput) (*ssm.LabelParameterVersionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.LabelParameterVersionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.LabelParameterVersionInput) *ssm.LabelParameterVersionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.LabelParameterVersionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.LabelParameterVersionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// LabelParameterVersionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) LabelParameterVersionRequest(_a0 *ssm.LabelParameterVersionInput) (*request.Request, *ssm.LabelParameterVersionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.LabelParameterVersionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.LabelParameterVersionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.LabelParameterVersionInput) *ssm.LabelParameterVersionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.LabelParameterVersionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// LabelParameterVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) LabelParameterVersionWithContext(_a0 context.Context, _a1 *ssm.LabelParameterVersionInput, _a2 ...request.Option) (*ssm.LabelParameterVersionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.LabelParameterVersionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.LabelParameterVersionInput, ...request.Option) *ssm.LabelParameterVersionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.LabelParameterVersionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.LabelParameterVersionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListAssociationVersions provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListAssociationVersions(_a0 *ssm.ListAssociationVersionsInput) (*ssm.ListAssociationVersionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListAssociationVersionsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationVersionsInput) *ssm.ListAssociationVersionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListAssociationVersionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListAssociationVersionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListAssociationVersionsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListAssociationVersionsPages(_a0 *ssm.ListAssociationVersionsInput, _a1 func(*ssm.ListAssociationVersionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationVersionsInput, func(*ssm.ListAssociationVersionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListAssociationVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListAssociationVersionsPagesWithContext(_a0 context.Context, _a1 *ssm.ListAssociationVersionsInput, _a2 func(*ssm.ListAssociationVersionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListAssociationVersionsInput, func(*ssm.ListAssociationVersionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListAssociationVersionsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListAssociationVersionsRequest(_a0 *ssm.ListAssociationVersionsInput) (*request.Request, *ssm.ListAssociationVersionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationVersionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListAssociationVersionsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListAssociationVersionsInput) *ssm.ListAssociationVersionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListAssociationVersionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListAssociationVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListAssociationVersionsWithContext(_a0 context.Context, _a1 *ssm.ListAssociationVersionsInput, _a2 ...request.Option) (*ssm.ListAssociationVersionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListAssociationVersionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListAssociationVersionsInput, ...request.Option) *ssm.ListAssociationVersionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListAssociationVersionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListAssociationVersionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListAssociations provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListAssociations(_a0 *ssm.ListAssociationsInput) (*ssm.ListAssociationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListAssociationsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationsInput) *ssm.ListAssociationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListAssociationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListAssociationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListAssociationsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListAssociationsPages(_a0 *ssm.ListAssociationsInput, _a1 func(*ssm.ListAssociationsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationsInput, func(*ssm.ListAssociationsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListAssociationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListAssociationsPagesWithContext(_a0 context.Context, _a1 *ssm.ListAssociationsInput, _a2 func(*ssm.ListAssociationsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListAssociationsInput, func(*ssm.ListAssociationsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListAssociationsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListAssociationsRequest(_a0 *ssm.ListAssociationsInput) (*request.Request, *ssm.ListAssociationsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListAssociationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListAssociationsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListAssociationsInput) *ssm.ListAssociationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListAssociationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListAssociationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListAssociationsWithContext(_a0 context.Context, _a1 *ssm.ListAssociationsInput, _a2 ...request.Option) (*ssm.ListAssociationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListAssociationsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListAssociationsInput, ...request.Option) *ssm.ListAssociationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListAssociationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListAssociationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListCommandInvocations provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListCommandInvocations(_a0 *ssm.ListCommandInvocationsInput) (*ssm.ListCommandInvocationsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListCommandInvocationsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListCommandInvocationsInput) *ssm.ListCommandInvocationsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListCommandInvocationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListCommandInvocationsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListCommandInvocationsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListCommandInvocationsPages(_a0 *ssm.ListCommandInvocationsInput, _a1 func(*ssm.ListCommandInvocationsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListCommandInvocationsInput, func(*ssm.ListCommandInvocationsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListCommandInvocationsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListCommandInvocationsPagesWithContext(_a0 context.Context, _a1 *ssm.ListCommandInvocationsInput, _a2 func(*ssm.ListCommandInvocationsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListCommandInvocationsInput, func(*ssm.ListCommandInvocationsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListCommandInvocationsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListCommandInvocationsRequest(_a0 *ssm.ListCommandInvocationsInput) (*request.Request, *ssm.ListCommandInvocationsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListCommandInvocationsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListCommandInvocationsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListCommandInvocationsInput) *ssm.ListCommandInvocationsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListCommandInvocationsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListCommandInvocationsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListCommandInvocationsWithContext(_a0 context.Context, _a1 *ssm.ListCommandInvocationsInput, _a2 ...request.Option) (*ssm.ListCommandInvocationsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListCommandInvocationsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListCommandInvocationsInput, ...request.Option) *ssm.ListCommandInvocationsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListCommandInvocationsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListCommandInvocationsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListCommands provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListCommands(_a0 *ssm.ListCommandsInput) (*ssm.ListCommandsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListCommandsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListCommandsInput) *ssm.ListCommandsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListCommandsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListCommandsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListCommandsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListCommandsPages(_a0 *ssm.ListCommandsInput, _a1 func(*ssm.ListCommandsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListCommandsInput, func(*ssm.ListCommandsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListCommandsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListCommandsPagesWithContext(_a0 context.Context, _a1 *ssm.ListCommandsInput, _a2 func(*ssm.ListCommandsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListCommandsInput, func(*ssm.ListCommandsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListCommandsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListCommandsRequest(_a0 *ssm.ListCommandsInput) (*request.Request, *ssm.ListCommandsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListCommandsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListCommandsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListCommandsInput) *ssm.ListCommandsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListCommandsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListCommandsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListCommandsWithContext(_a0 context.Context, _a1 *ssm.ListCommandsInput, _a2 ...request.Option) (*ssm.ListCommandsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListCommandsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListCommandsInput, ...request.Option) *ssm.ListCommandsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListCommandsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListCommandsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListComplianceItems provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListComplianceItems(_a0 *ssm.ListComplianceItemsInput) (*ssm.ListComplianceItemsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListComplianceItemsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceItemsInput) *ssm.ListComplianceItemsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListComplianceItemsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListComplianceItemsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListComplianceItemsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListComplianceItemsPages(_a0 *ssm.ListComplianceItemsInput, _a1 func(*ssm.ListComplianceItemsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceItemsInput, func(*ssm.ListComplianceItemsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListComplianceItemsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListComplianceItemsPagesWithContext(_a0 context.Context, _a1 *ssm.ListComplianceItemsInput, _a2 func(*ssm.ListComplianceItemsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListComplianceItemsInput, func(*ssm.ListComplianceItemsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListComplianceItemsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListComplianceItemsRequest(_a0 *ssm.ListComplianceItemsInput) (*request.Request, *ssm.ListComplianceItemsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceItemsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListComplianceItemsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListComplianceItemsInput) *ssm.ListComplianceItemsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListComplianceItemsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListComplianceItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListComplianceItemsWithContext(_a0 context.Context, _a1 *ssm.ListComplianceItemsInput, _a2 ...request.Option) (*ssm.ListComplianceItemsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListComplianceItemsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListComplianceItemsInput, ...request.Option) *ssm.ListComplianceItemsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListComplianceItemsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListComplianceItemsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListComplianceSummaries provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListComplianceSummaries(_a0 *ssm.ListComplianceSummariesInput) (*ssm.ListComplianceSummariesOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListComplianceSummariesOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceSummariesInput) *ssm.ListComplianceSummariesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListComplianceSummariesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListComplianceSummariesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListComplianceSummariesPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListComplianceSummariesPages(_a0 *ssm.ListComplianceSummariesInput, _a1 func(*ssm.ListComplianceSummariesOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceSummariesInput, func(*ssm.ListComplianceSummariesOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListComplianceSummariesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListComplianceSummariesPagesWithContext(_a0 context.Context, _a1 *ssm.ListComplianceSummariesInput, _a2 func(*ssm.ListComplianceSummariesOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListComplianceSummariesInput, func(*ssm.ListComplianceSummariesOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListComplianceSummariesRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListComplianceSummariesRequest(_a0 *ssm.ListComplianceSummariesInput) (*request.Request, *ssm.ListComplianceSummariesOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListComplianceSummariesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListComplianceSummariesOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListComplianceSummariesInput) *ssm.ListComplianceSummariesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListComplianceSummariesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListComplianceSummariesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListComplianceSummariesWithContext(_a0 context.Context, _a1 *ssm.ListComplianceSummariesInput, _a2 ...request.Option) (*ssm.ListComplianceSummariesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListComplianceSummariesOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListComplianceSummariesInput, ...request.Option) *ssm.ListComplianceSummariesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListComplianceSummariesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListComplianceSummariesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListDocumentMetadataHistory provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListDocumentMetadataHistory(_a0 *ssm.ListDocumentMetadataHistoryInput) (*ssm.ListDocumentMetadataHistoryOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListDocumentMetadataHistoryOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentMetadataHistoryInput) *ssm.ListDocumentMetadataHistoryOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListDocumentMetadataHistoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListDocumentMetadataHistoryInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListDocumentMetadataHistoryRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListDocumentMetadataHistoryRequest(_a0 *ssm.ListDocumentMetadataHistoryInput) (*request.Request, *ssm.ListDocumentMetadataHistoryOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentMetadataHistoryInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListDocumentMetadataHistoryOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListDocumentMetadataHistoryInput) *ssm.ListDocumentMetadataHistoryOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListDocumentMetadataHistoryOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListDocumentMetadataHistoryWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListDocumentMetadataHistoryWithContext(_a0 context.Context, _a1 *ssm.ListDocumentMetadataHistoryInput, _a2 ...request.Option) (*ssm.ListDocumentMetadataHistoryOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListDocumentMetadataHistoryOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentMetadataHistoryInput, ...request.Option) *ssm.ListDocumentMetadataHistoryOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListDocumentMetadataHistoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListDocumentMetadataHistoryInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListDocumentVersions provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListDocumentVersions(_a0 *ssm.ListDocumentVersionsInput) (*ssm.ListDocumentVersionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListDocumentVersionsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentVersionsInput) *ssm.ListDocumentVersionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListDocumentVersionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListDocumentVersionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListDocumentVersionsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListDocumentVersionsPages(_a0 *ssm.ListDocumentVersionsInput, _a1 func(*ssm.ListDocumentVersionsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentVersionsInput, func(*ssm.ListDocumentVersionsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListDocumentVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListDocumentVersionsPagesWithContext(_a0 context.Context, _a1 *ssm.ListDocumentVersionsInput, _a2 func(*ssm.ListDocumentVersionsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentVersionsInput, func(*ssm.ListDocumentVersionsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListDocumentVersionsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListDocumentVersionsRequest(_a0 *ssm.ListDocumentVersionsInput) (*request.Request, *ssm.ListDocumentVersionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentVersionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListDocumentVersionsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListDocumentVersionsInput) *ssm.ListDocumentVersionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListDocumentVersionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListDocumentVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListDocumentVersionsWithContext(_a0 context.Context, _a1 *ssm.ListDocumentVersionsInput, _a2 ...request.Option) (*ssm.ListDocumentVersionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListDocumentVersionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentVersionsInput, ...request.Option) *ssm.ListDocumentVersionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListDocumentVersionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListDocumentVersionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListDocuments provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListDocuments(_a0 *ssm.ListDocumentsInput) (*ssm.ListDocumentsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListDocumentsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentsInput) *ssm.ListDocumentsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListDocumentsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListDocumentsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListDocumentsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListDocumentsPages(_a0 *ssm.ListDocumentsInput, _a1 func(*ssm.ListDocumentsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentsInput, func(*ssm.ListDocumentsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListDocumentsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListDocumentsPagesWithContext(_a0 context.Context, _a1 *ssm.ListDocumentsInput, _a2 func(*ssm.ListDocumentsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentsInput, func(*ssm.ListDocumentsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListDocumentsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListDocumentsRequest(_a0 *ssm.ListDocumentsInput) (*request.Request, *ssm.ListDocumentsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListDocumentsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListDocumentsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListDocumentsInput) *ssm.ListDocumentsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListDocumentsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListDocumentsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListDocumentsWithContext(_a0 context.Context, _a1 *ssm.ListDocumentsInput, _a2 ...request.Option) (*ssm.ListDocumentsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListDocumentsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListDocumentsInput, ...request.Option) *ssm.ListDocumentsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListDocumentsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListDocumentsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListInventoryEntries provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListInventoryEntries(_a0 *ssm.ListInventoryEntriesInput) (*ssm.ListInventoryEntriesOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListInventoryEntriesOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListInventoryEntriesInput) *ssm.ListInventoryEntriesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListInventoryEntriesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListInventoryEntriesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListInventoryEntriesRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListInventoryEntriesRequest(_a0 *ssm.ListInventoryEntriesInput) (*request.Request, *ssm.ListInventoryEntriesOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListInventoryEntriesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListInventoryEntriesOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListInventoryEntriesInput) *ssm.ListInventoryEntriesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListInventoryEntriesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListInventoryEntriesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListInventoryEntriesWithContext(_a0 context.Context, _a1 *ssm.ListInventoryEntriesInput, _a2 ...request.Option) (*ssm.ListInventoryEntriesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListInventoryEntriesOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListInventoryEntriesInput, ...request.Option) *ssm.ListInventoryEntriesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListInventoryEntriesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListInventoryEntriesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListOpsItemEvents provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListOpsItemEvents(_a0 *ssm.ListOpsItemEventsInput) (*ssm.ListOpsItemEventsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListOpsItemEventsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemEventsInput) *ssm.ListOpsItemEventsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListOpsItemEventsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListOpsItemEventsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListOpsItemEventsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListOpsItemEventsPages(_a0 *ssm.ListOpsItemEventsInput, _a1 func(*ssm.ListOpsItemEventsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemEventsInput, func(*ssm.ListOpsItemEventsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListOpsItemEventsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListOpsItemEventsPagesWithContext(_a0 context.Context, _a1 *ssm.ListOpsItemEventsInput, _a2 func(*ssm.ListOpsItemEventsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemEventsInput, func(*ssm.ListOpsItemEventsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListOpsItemEventsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListOpsItemEventsRequest(_a0 *ssm.ListOpsItemEventsInput) (*request.Request, *ssm.ListOpsItemEventsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemEventsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListOpsItemEventsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListOpsItemEventsInput) *ssm.ListOpsItemEventsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListOpsItemEventsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListOpsItemEventsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListOpsItemEventsWithContext(_a0 context.Context, _a1 *ssm.ListOpsItemEventsInput, _a2 ...request.Option) (*ssm.ListOpsItemEventsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListOpsItemEventsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemEventsInput, ...request.Option) *ssm.ListOpsItemEventsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListOpsItemEventsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListOpsItemEventsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListOpsItemRelatedItems provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListOpsItemRelatedItems(_a0 *ssm.ListOpsItemRelatedItemsInput) (*ssm.ListOpsItemRelatedItemsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListOpsItemRelatedItemsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemRelatedItemsInput) *ssm.ListOpsItemRelatedItemsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListOpsItemRelatedItemsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListOpsItemRelatedItemsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListOpsItemRelatedItemsPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListOpsItemRelatedItemsPages(_a0 *ssm.ListOpsItemRelatedItemsInput, _a1 func(*ssm.ListOpsItemRelatedItemsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemRelatedItemsInput, func(*ssm.ListOpsItemRelatedItemsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListOpsItemRelatedItemsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListOpsItemRelatedItemsPagesWithContext(_a0 context.Context, _a1 *ssm.ListOpsItemRelatedItemsInput, _a2 func(*ssm.ListOpsItemRelatedItemsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemRelatedItemsInput, func(*ssm.ListOpsItemRelatedItemsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListOpsItemRelatedItemsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListOpsItemRelatedItemsRequest(_a0 *ssm.ListOpsItemRelatedItemsInput) (*request.Request, *ssm.ListOpsItemRelatedItemsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsItemRelatedItemsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListOpsItemRelatedItemsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListOpsItemRelatedItemsInput) *ssm.ListOpsItemRelatedItemsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListOpsItemRelatedItemsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListOpsItemRelatedItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListOpsItemRelatedItemsWithContext(_a0 context.Context, _a1 *ssm.ListOpsItemRelatedItemsInput, _a2 ...request.Option) (*ssm.ListOpsItemRelatedItemsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListOpsItemRelatedItemsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsItemRelatedItemsInput, ...request.Option) *ssm.ListOpsItemRelatedItemsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListOpsItemRelatedItemsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListOpsItemRelatedItemsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListOpsMetadata provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListOpsMetadata(_a0 *ssm.ListOpsMetadataInput) (*ssm.ListOpsMetadataOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsMetadataInput) *ssm.ListOpsMetadataOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListOpsMetadataInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListOpsMetadataPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListOpsMetadataPages(_a0 *ssm.ListOpsMetadataInput, _a1 func(*ssm.ListOpsMetadataOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsMetadataInput, func(*ssm.ListOpsMetadataOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListOpsMetadataPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListOpsMetadataPagesWithContext(_a0 context.Context, _a1 *ssm.ListOpsMetadataInput, _a2 func(*ssm.ListOpsMetadataOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsMetadataInput, func(*ssm.ListOpsMetadataOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListOpsMetadataRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListOpsMetadataRequest(_a0 *ssm.ListOpsMetadataInput) (*request.Request, *ssm.ListOpsMetadataOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListOpsMetadataInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListOpsMetadataOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListOpsMetadataInput) *ssm.ListOpsMetadataOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListOpsMetadataOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.ListOpsMetadataInput, _a2 ...request.Option) (*ssm.ListOpsMetadataOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListOpsMetadataInput, ...request.Option) *ssm.ListOpsMetadataOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListOpsMetadataInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListResourceComplianceSummaries provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListResourceComplianceSummaries(_a0 *ssm.ListResourceComplianceSummariesInput) (*ssm.ListResourceComplianceSummariesOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListResourceComplianceSummariesOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListResourceComplianceSummariesInput) *ssm.ListResourceComplianceSummariesOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListResourceComplianceSummariesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListResourceComplianceSummariesInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListResourceComplianceSummariesPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListResourceComplianceSummariesPages(_a0 *ssm.ListResourceComplianceSummariesInput, _a1 func(*ssm.ListResourceComplianceSummariesOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListResourceComplianceSummariesInput, func(*ssm.ListResourceComplianceSummariesOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListResourceComplianceSummariesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListResourceComplianceSummariesPagesWithContext(_a0 context.Context, _a1 *ssm.ListResourceComplianceSummariesInput, _a2 func(*ssm.ListResourceComplianceSummariesOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourceComplianceSummariesInput, func(*ssm.ListResourceComplianceSummariesOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListResourceComplianceSummariesRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListResourceComplianceSummariesRequest(_a0 *ssm.ListResourceComplianceSummariesInput) (*request.Request, *ssm.ListResourceComplianceSummariesOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListResourceComplianceSummariesInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListResourceComplianceSummariesOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListResourceComplianceSummariesInput) *ssm.ListResourceComplianceSummariesOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListResourceComplianceSummariesOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListResourceComplianceSummariesWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListResourceComplianceSummariesWithContext(_a0 context.Context, _a1 *ssm.ListResourceComplianceSummariesInput, _a2 ...request.Option) (*ssm.ListResourceComplianceSummariesOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListResourceComplianceSummariesOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourceComplianceSummariesInput, ...request.Option) *ssm.ListResourceComplianceSummariesOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListResourceComplianceSummariesOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListResourceComplianceSummariesInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListResourceDataSync provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListResourceDataSync(_a0 *ssm.ListResourceDataSyncInput) (*ssm.ListResourceDataSyncOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListResourceDataSyncOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListResourceDataSyncInput) *ssm.ListResourceDataSyncOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListResourceDataSyncOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListResourceDataSyncInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListResourceDataSyncPages provides a mock function with given fields: _a0, _a1
-func (_m *SSMAPI) ListResourceDataSyncPages(_a0 *ssm.ListResourceDataSyncInput, _a1 func(*ssm.ListResourceDataSyncOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.ListResourceDataSyncInput, func(*ssm.ListResourceDataSyncOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListResourceDataSyncPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SSMAPI) ListResourceDataSyncPagesWithContext(_a0 context.Context, _a1 *ssm.ListResourceDataSyncInput, _a2 func(*ssm.ListResourceDataSyncOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourceDataSyncInput, func(*ssm.ListResourceDataSyncOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListResourceDataSyncRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListResourceDataSyncRequest(_a0 *ssm.ListResourceDataSyncInput) (*request.Request, *ssm.ListResourceDataSyncOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListResourceDataSyncInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListResourceDataSyncOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListResourceDataSyncInput) *ssm.ListResourceDataSyncOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListResourceDataSyncOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListResourceDataSyncWithContext(_a0 context.Context, _a1 *ssm.ListResourceDataSyncInput, _a2 ...request.Option) (*ssm.ListResourceDataSyncOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListResourceDataSyncOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListResourceDataSyncInput, ...request.Option) *ssm.ListResourceDataSyncOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListResourceDataSyncOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListResourceDataSyncInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListTagsForResource provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListTagsForResource(_a0 *ssm.ListTagsForResourceInput) (*ssm.ListTagsForResourceOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ListTagsForResourceOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ListTagsForResourceInput) *ssm.ListTagsForResourceOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListTagsForResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ListTagsForResourceInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListTagsForResourceRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ListTagsForResourceRequest(_a0 *ssm.ListTagsForResourceInput) (*request.Request, *ssm.ListTagsForResourceOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ListTagsForResourceInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ListTagsForResourceOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ListTagsForResourceInput) *ssm.ListTagsForResourceOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ListTagsForResourceOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ListTagsForResourceWithContext(_a0 context.Context, _a1 *ssm.ListTagsForResourceInput, _a2 ...request.Option) (*ssm.ListTagsForResourceOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ListTagsForResourceOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ListTagsForResourceInput, ...request.Option) *ssm.ListTagsForResourceOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ListTagsForResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ListTagsForResourceInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ModifyDocumentPermission provides a mock function with given fields: _a0
-func (_m *SSMAPI) ModifyDocumentPermission(_a0 *ssm.ModifyDocumentPermissionInput) (*ssm.ModifyDocumentPermissionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ModifyDocumentPermissionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ModifyDocumentPermissionInput) *ssm.ModifyDocumentPermissionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ModifyDocumentPermissionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ModifyDocumentPermissionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ModifyDocumentPermissionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ModifyDocumentPermissionRequest(_a0 *ssm.ModifyDocumentPermissionInput) (*request.Request, *ssm.ModifyDocumentPermissionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ModifyDocumentPermissionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ModifyDocumentPermissionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ModifyDocumentPermissionInput) *ssm.ModifyDocumentPermissionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ModifyDocumentPermissionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ModifyDocumentPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ModifyDocumentPermissionWithContext(_a0 context.Context, _a1 *ssm.ModifyDocumentPermissionInput, _a2 ...request.Option) (*ssm.ModifyDocumentPermissionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ModifyDocumentPermissionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ModifyDocumentPermissionInput, ...request.Option) *ssm.ModifyDocumentPermissionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ModifyDocumentPermissionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ModifyDocumentPermissionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutComplianceItems provides a mock function with given fields: _a0
-func (_m *SSMAPI) PutComplianceItems(_a0 *ssm.PutComplianceItemsInput) (*ssm.PutComplianceItemsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.PutComplianceItemsOutput
-	if rf, ok := ret.Get(0).(func(*ssm.PutComplianceItemsInput) *ssm.PutComplianceItemsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.PutComplianceItemsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.PutComplianceItemsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutComplianceItemsRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) PutComplianceItemsRequest(_a0 *ssm.PutComplianceItemsInput) (*request.Request, *ssm.PutComplianceItemsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.PutComplianceItemsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.PutComplianceItemsOutput
-	if rf, ok := ret.Get(1).(func(*ssm.PutComplianceItemsInput) *ssm.PutComplianceItemsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.PutComplianceItemsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// PutComplianceItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) PutComplianceItemsWithContext(_a0 context.Context, _a1 *ssm.PutComplianceItemsInput, _a2 ...request.Option) (*ssm.PutComplianceItemsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.PutComplianceItemsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutComplianceItemsInput, ...request.Option) *ssm.PutComplianceItemsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.PutComplianceItemsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.PutComplianceItemsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutInventory provides a mock function with given fields: _a0
-func (_m *SSMAPI) PutInventory(_a0 *ssm.PutInventoryInput) (*ssm.PutInventoryOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.PutInventoryOutput
-	if rf, ok := ret.Get(0).(func(*ssm.PutInventoryInput) *ssm.PutInventoryOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.PutInventoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.PutInventoryInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutInventoryRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) PutInventoryRequest(_a0 *ssm.PutInventoryInput) (*request.Request, *ssm.PutInventoryOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.PutInventoryInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.PutInventoryOutput
-	if rf, ok := ret.Get(1).(func(*ssm.PutInventoryInput) *ssm.PutInventoryOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.PutInventoryOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// PutInventoryWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) PutInventoryWithContext(_a0 context.Context, _a1 *ssm.PutInventoryInput, _a2 ...request.Option) (*ssm.PutInventoryOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.PutInventoryOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutInventoryInput, ...request.Option) *ssm.PutInventoryOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.PutInventoryOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.PutInventoryInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutParameter provides a mock function with given fields: _a0
-func (_m *SSMAPI) PutParameter(_a0 *ssm.PutParameterInput) (*ssm.PutParameterOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.PutParameterOutput
-	if rf, ok := ret.Get(0).(func(*ssm.PutParameterInput) *ssm.PutParameterOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.PutParameterOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.PutParameterInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutParameterRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) PutParameterRequest(_a0 *ssm.PutParameterInput) (*request.Request, *ssm.PutParameterOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.PutParameterInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.PutParameterOutput
-	if rf, ok := ret.Get(1).(func(*ssm.PutParameterInput) *ssm.PutParameterOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.PutParameterOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// PutParameterWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) PutParameterWithContext(_a0 context.Context, _a1 *ssm.PutParameterInput, _a2 ...request.Option) (*ssm.PutParameterOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.PutParameterOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.PutParameterInput, ...request.Option) *ssm.PutParameterOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.PutParameterOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.PutParameterInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterDefaultPatchBaseline provides a mock function with given fields: _a0
-func (_m *SSMAPI) RegisterDefaultPatchBaseline(_a0 *ssm.RegisterDefaultPatchBaselineInput) (*ssm.RegisterDefaultPatchBaselineOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.RegisterDefaultPatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(*ssm.RegisterDefaultPatchBaselineInput) *ssm.RegisterDefaultPatchBaselineOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RegisterDefaultPatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.RegisterDefaultPatchBaselineInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterDefaultPatchBaselineRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) RegisterDefaultPatchBaselineRequest(_a0 *ssm.RegisterDefaultPatchBaselineInput) (*request.Request, *ssm.RegisterDefaultPatchBaselineOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.RegisterDefaultPatchBaselineInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.RegisterDefaultPatchBaselineOutput
-	if rf, ok := ret.Get(1).(func(*ssm.RegisterDefaultPatchBaselineInput) *ssm.RegisterDefaultPatchBaselineOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.RegisterDefaultPatchBaselineOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// RegisterDefaultPatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) RegisterDefaultPatchBaselineWithContext(_a0 context.Context, _a1 *ssm.RegisterDefaultPatchBaselineInput, _a2 ...request.Option) (*ssm.RegisterDefaultPatchBaselineOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.RegisterDefaultPatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterDefaultPatchBaselineInput, ...request.Option) *ssm.RegisterDefaultPatchBaselineOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RegisterDefaultPatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.RegisterDefaultPatchBaselineInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterPatchBaselineForPatchGroup provides a mock function with given fields: _a0
-func (_m *SSMAPI) RegisterPatchBaselineForPatchGroup(_a0 *ssm.RegisterPatchBaselineForPatchGroupInput) (*ssm.RegisterPatchBaselineForPatchGroupOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.RegisterPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(0).(func(*ssm.RegisterPatchBaselineForPatchGroupInput) *ssm.RegisterPatchBaselineForPatchGroupOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RegisterPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.RegisterPatchBaselineForPatchGroupInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterPatchBaselineForPatchGroupRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) RegisterPatchBaselineForPatchGroupRequest(_a0 *ssm.RegisterPatchBaselineForPatchGroupInput) (*request.Request, *ssm.RegisterPatchBaselineForPatchGroupOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.RegisterPatchBaselineForPatchGroupInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.RegisterPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(1).(func(*ssm.RegisterPatchBaselineForPatchGroupInput) *ssm.RegisterPatchBaselineForPatchGroupOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.RegisterPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// RegisterPatchBaselineForPatchGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) RegisterPatchBaselineForPatchGroupWithContext(_a0 context.Context, _a1 *ssm.RegisterPatchBaselineForPatchGroupInput, _a2 ...request.Option) (*ssm.RegisterPatchBaselineForPatchGroupOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.RegisterPatchBaselineForPatchGroupOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterPatchBaselineForPatchGroupInput, ...request.Option) *ssm.RegisterPatchBaselineForPatchGroupOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RegisterPatchBaselineForPatchGroupOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.RegisterPatchBaselineForPatchGroupInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterTargetWithMaintenanceWindow provides a mock function with given fields: _a0
-func (_m *SSMAPI) RegisterTargetWithMaintenanceWindow(_a0 *ssm.RegisterTargetWithMaintenanceWindowInput) (*ssm.RegisterTargetWithMaintenanceWindowOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.RegisterTargetWithMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) *ssm.RegisterTargetWithMaintenanceWindowOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RegisterTargetWithMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterTargetWithMaintenanceWindowRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) RegisterTargetWithMaintenanceWindowRequest(_a0 *ssm.RegisterTargetWithMaintenanceWindowInput) (*request.Request, *ssm.RegisterTargetWithMaintenanceWindowOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.RegisterTargetWithMaintenanceWindowOutput
-	if rf, ok := ret.Get(1).(func(*ssm.RegisterTargetWithMaintenanceWindowInput) *ssm.RegisterTargetWithMaintenanceWindowOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.RegisterTargetWithMaintenanceWindowOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// RegisterTargetWithMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) RegisterTargetWithMaintenanceWindowWithContext(_a0 context.Context, _a1 *ssm.RegisterTargetWithMaintenanceWindowInput, _a2 ...request.Option) (*ssm.RegisterTargetWithMaintenanceWindowOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.RegisterTargetWithMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterTargetWithMaintenanceWindowInput, ...request.Option) *ssm.RegisterTargetWithMaintenanceWindowOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RegisterTargetWithMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.RegisterTargetWithMaintenanceWindowInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterTaskWithMaintenanceWindow provides a mock function with given fields: _a0
-func (_m *SSMAPI) RegisterTaskWithMaintenanceWindow(_a0 *ssm.RegisterTaskWithMaintenanceWindowInput) (*ssm.RegisterTaskWithMaintenanceWindowOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.RegisterTaskWithMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) *ssm.RegisterTaskWithMaintenanceWindowOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RegisterTaskWithMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RegisterTaskWithMaintenanceWindowRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) RegisterTaskWithMaintenanceWindowRequest(_a0 *ssm.RegisterTaskWithMaintenanceWindowInput) (*request.Request, *ssm.RegisterTaskWithMaintenanceWindowOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.RegisterTaskWithMaintenanceWindowOutput
-	if rf, ok := ret.Get(1).(func(*ssm.RegisterTaskWithMaintenanceWindowInput) *ssm.RegisterTaskWithMaintenanceWindowOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.RegisterTaskWithMaintenanceWindowOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// RegisterTaskWithMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) RegisterTaskWithMaintenanceWindowWithContext(_a0 context.Context, _a1 *ssm.RegisterTaskWithMaintenanceWindowInput, _a2 ...request.Option) (*ssm.RegisterTaskWithMaintenanceWindowOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.RegisterTaskWithMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RegisterTaskWithMaintenanceWindowInput, ...request.Option) *ssm.RegisterTaskWithMaintenanceWindowOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RegisterTaskWithMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.RegisterTaskWithMaintenanceWindowInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RemoveTagsFromResource provides a mock function with given fields: _a0
-func (_m *SSMAPI) RemoveTagsFromResource(_a0 *ssm.RemoveTagsFromResourceInput) (*ssm.RemoveTagsFromResourceOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.RemoveTagsFromResourceOutput
-	if rf, ok := ret.Get(0).(func(*ssm.RemoveTagsFromResourceInput) *ssm.RemoveTagsFromResourceOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RemoveTagsFromResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.RemoveTagsFromResourceInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RemoveTagsFromResourceRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) RemoveTagsFromResourceRequest(_a0 *ssm.RemoveTagsFromResourceInput) (*request.Request, *ssm.RemoveTagsFromResourceOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.RemoveTagsFromResourceInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.RemoveTagsFromResourceOutput
-	if rf, ok := ret.Get(1).(func(*ssm.RemoveTagsFromResourceInput) *ssm.RemoveTagsFromResourceOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.RemoveTagsFromResourceOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// RemoveTagsFromResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) RemoveTagsFromResourceWithContext(_a0 context.Context, _a1 *ssm.RemoveTagsFromResourceInput, _a2 ...request.Option) (*ssm.RemoveTagsFromResourceOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.RemoveTagsFromResourceOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.RemoveTagsFromResourceInput, ...request.Option) *ssm.RemoveTagsFromResourceOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.RemoveTagsFromResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.RemoveTagsFromResourceInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ResetServiceSetting provides a mock function with given fields: _a0
-func (_m *SSMAPI) ResetServiceSetting(_a0 *ssm.ResetServiceSettingInput) (*ssm.ResetServiceSettingOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ResetServiceSettingOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ResetServiceSettingInput) *ssm.ResetServiceSettingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ResetServiceSettingOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ResetServiceSettingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ResetServiceSettingRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ResetServiceSettingRequest(_a0 *ssm.ResetServiceSettingInput) (*request.Request, *ssm.ResetServiceSettingOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ResetServiceSettingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ResetServiceSettingOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ResetServiceSettingInput) *ssm.ResetServiceSettingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ResetServiceSettingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ResetServiceSettingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ResetServiceSettingWithContext(_a0 context.Context, _a1 *ssm.ResetServiceSettingInput, _a2 ...request.Option) (*ssm.ResetServiceSettingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ResetServiceSettingOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ResetServiceSettingInput, ...request.Option) *ssm.ResetServiceSettingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ResetServiceSettingOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ResetServiceSettingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ResumeSession provides a mock function with given fields: _a0
-func (_m *SSMAPI) ResumeSession(_a0 *ssm.ResumeSessionInput) (*ssm.ResumeSessionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.ResumeSessionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.ResumeSessionInput) *ssm.ResumeSessionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ResumeSessionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.ResumeSessionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ResumeSessionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) ResumeSessionRequest(_a0 *ssm.ResumeSessionInput) (*request.Request, *ssm.ResumeSessionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.ResumeSessionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.ResumeSessionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.ResumeSessionInput) *ssm.ResumeSessionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.ResumeSessionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ResumeSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) ResumeSessionWithContext(_a0 context.Context, _a1 *ssm.ResumeSessionInput, _a2 ...request.Option) (*ssm.ResumeSessionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.ResumeSessionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.ResumeSessionInput, ...request.Option) *ssm.ResumeSessionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.ResumeSessionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.ResumeSessionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SendAutomationSignal provides a mock function with given fields: _a0
-func (_m *SSMAPI) SendAutomationSignal(_a0 *ssm.SendAutomationSignalInput) (*ssm.SendAutomationSignalOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.SendAutomationSignalOutput
-	if rf, ok := ret.Get(0).(func(*ssm.SendAutomationSignalInput) *ssm.SendAutomationSignalOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.SendAutomationSignalOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.SendAutomationSignalInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SendAutomationSignalRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) SendAutomationSignalRequest(_a0 *ssm.SendAutomationSignalInput) (*request.Request, *ssm.SendAutomationSignalOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.SendAutomationSignalInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.SendAutomationSignalOutput
-	if rf, ok := ret.Get(1).(func(*ssm.SendAutomationSignalInput) *ssm.SendAutomationSignalOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.SendAutomationSignalOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// SendAutomationSignalWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) SendAutomationSignalWithContext(_a0 context.Context, _a1 *ssm.SendAutomationSignalInput, _a2 ...request.Option) (*ssm.SendAutomationSignalOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.SendAutomationSignalOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.SendAutomationSignalInput, ...request.Option) *ssm.SendAutomationSignalOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.SendAutomationSignalOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.SendAutomationSignalInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SendCommand provides a mock function with given fields: _a0
-func (_m *SSMAPI) SendCommand(_a0 *ssm.SendCommandInput) (*ssm.SendCommandOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.SendCommandOutput
-	if rf, ok := ret.Get(0).(func(*ssm.SendCommandInput) *ssm.SendCommandOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.SendCommandOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.SendCommandInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// SendCommandRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) SendCommandRequest(_a0 *ssm.SendCommandInput) (*request.Request, *ssm.SendCommandOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.SendCommandInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.SendCommandOutput
-	if rf, ok := ret.Get(1).(func(*ssm.SendCommandInput) *ssm.SendCommandOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.SendCommandOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// SendCommandWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) SendCommandWithContext(_a0 context.Context, _a1 *ssm.SendCommandInput, _a2 ...request.Option) (*ssm.SendCommandOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.SendCommandOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.SendCommandInput, ...request.Option) *ssm.SendCommandOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.SendCommandOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.SendCommandInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StartAssociationsOnce provides a mock function with given fields: _a0
-func (_m *SSMAPI) StartAssociationsOnce(_a0 *ssm.StartAssociationsOnceInput) (*ssm.StartAssociationsOnceOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.StartAssociationsOnceOutput
-	if rf, ok := ret.Get(0).(func(*ssm.StartAssociationsOnceInput) *ssm.StartAssociationsOnceOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StartAssociationsOnceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.StartAssociationsOnceInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StartAssociationsOnceRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) StartAssociationsOnceRequest(_a0 *ssm.StartAssociationsOnceInput) (*request.Request, *ssm.StartAssociationsOnceOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.StartAssociationsOnceInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.StartAssociationsOnceOutput
-	if rf, ok := ret.Get(1).(func(*ssm.StartAssociationsOnceInput) *ssm.StartAssociationsOnceOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.StartAssociationsOnceOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// StartAssociationsOnceWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) StartAssociationsOnceWithContext(_a0 context.Context, _a1 *ssm.StartAssociationsOnceInput, _a2 ...request.Option) (*ssm.StartAssociationsOnceOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.StartAssociationsOnceOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartAssociationsOnceInput, ...request.Option) *ssm.StartAssociationsOnceOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StartAssociationsOnceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.StartAssociationsOnceInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StartAutomationExecution provides a mock function with given fields: _a0
-func (_m *SSMAPI) StartAutomationExecution(_a0 *ssm.StartAutomationExecutionInput) (*ssm.StartAutomationExecutionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.StartAutomationExecutionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.StartAutomationExecutionInput) *ssm.StartAutomationExecutionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StartAutomationExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.StartAutomationExecutionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StartAutomationExecutionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) StartAutomationExecutionRequest(_a0 *ssm.StartAutomationExecutionInput) (*request.Request, *ssm.StartAutomationExecutionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.StartAutomationExecutionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.StartAutomationExecutionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.StartAutomationExecutionInput) *ssm.StartAutomationExecutionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.StartAutomationExecutionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// StartAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) StartAutomationExecutionWithContext(_a0 context.Context, _a1 *ssm.StartAutomationExecutionInput, _a2 ...request.Option) (*ssm.StartAutomationExecutionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.StartAutomationExecutionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartAutomationExecutionInput, ...request.Option) *ssm.StartAutomationExecutionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StartAutomationExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.StartAutomationExecutionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StartChangeRequestExecution provides a mock function with given fields: _a0
-func (_m *SSMAPI) StartChangeRequestExecution(_a0 *ssm.StartChangeRequestExecutionInput) (*ssm.StartChangeRequestExecutionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.StartChangeRequestExecutionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.StartChangeRequestExecutionInput) *ssm.StartChangeRequestExecutionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StartChangeRequestExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.StartChangeRequestExecutionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StartChangeRequestExecutionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) StartChangeRequestExecutionRequest(_a0 *ssm.StartChangeRequestExecutionInput) (*request.Request, *ssm.StartChangeRequestExecutionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.StartChangeRequestExecutionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.StartChangeRequestExecutionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.StartChangeRequestExecutionInput) *ssm.StartChangeRequestExecutionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.StartChangeRequestExecutionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// StartChangeRequestExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) StartChangeRequestExecutionWithContext(_a0 context.Context, _a1 *ssm.StartChangeRequestExecutionInput, _a2 ...request.Option) (*ssm.StartChangeRequestExecutionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.StartChangeRequestExecutionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartChangeRequestExecutionInput, ...request.Option) *ssm.StartChangeRequestExecutionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StartChangeRequestExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.StartChangeRequestExecutionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StartSession provides a mock function with given fields: _a0
-func (_m *SSMAPI) StartSession(_a0 *ssm.StartSessionInput) (*ssm.StartSessionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.StartSessionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.StartSessionInput) *ssm.StartSessionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StartSessionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.StartSessionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StartSessionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) StartSessionRequest(_a0 *ssm.StartSessionInput) (*request.Request, *ssm.StartSessionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.StartSessionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.StartSessionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.StartSessionInput) *ssm.StartSessionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.StartSessionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// StartSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) StartSessionWithContext(_a0 context.Context, _a1 *ssm.StartSessionInput, _a2 ...request.Option) (*ssm.StartSessionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.StartSessionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StartSessionInput, ...request.Option) *ssm.StartSessionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StartSessionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.StartSessionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StopAutomationExecution provides a mock function with given fields: _a0
-func (_m *SSMAPI) StopAutomationExecution(_a0 *ssm.StopAutomationExecutionInput) (*ssm.StopAutomationExecutionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.StopAutomationExecutionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.StopAutomationExecutionInput) *ssm.StopAutomationExecutionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StopAutomationExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.StopAutomationExecutionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StopAutomationExecutionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) StopAutomationExecutionRequest(_a0 *ssm.StopAutomationExecutionInput) (*request.Request, *ssm.StopAutomationExecutionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.StopAutomationExecutionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.StopAutomationExecutionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.StopAutomationExecutionInput) *ssm.StopAutomationExecutionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.StopAutomationExecutionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// StopAutomationExecutionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) StopAutomationExecutionWithContext(_a0 context.Context, _a1 *ssm.StopAutomationExecutionInput, _a2 ...request.Option) (*ssm.StopAutomationExecutionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.StopAutomationExecutionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.StopAutomationExecutionInput, ...request.Option) *ssm.StopAutomationExecutionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.StopAutomationExecutionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.StopAutomationExecutionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// TerminateSession provides a mock function with given fields: _a0
-func (_m *SSMAPI) TerminateSession(_a0 *ssm.TerminateSessionInput) (*ssm.TerminateSessionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.TerminateSessionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.TerminateSessionInput) *ssm.TerminateSessionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.TerminateSessionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.TerminateSessionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// TerminateSessionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) TerminateSessionRequest(_a0 *ssm.TerminateSessionInput) (*request.Request, *ssm.TerminateSessionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.TerminateSessionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.TerminateSessionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.TerminateSessionInput) *ssm.TerminateSessionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.TerminateSessionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// TerminateSessionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) TerminateSessionWithContext(_a0 context.Context, _a1 *ssm.TerminateSessionInput, _a2 ...request.Option) (*ssm.TerminateSessionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.TerminateSessionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.TerminateSessionInput, ...request.Option) *ssm.TerminateSessionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.TerminateSessionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.TerminateSessionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UnlabelParameterVersion provides a mock function with given fields: _a0
-func (_m *SSMAPI) UnlabelParameterVersion(_a0 *ssm.UnlabelParameterVersionInput) (*ssm.UnlabelParameterVersionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UnlabelParameterVersionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UnlabelParameterVersionInput) *ssm.UnlabelParameterVersionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UnlabelParameterVersionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UnlabelParameterVersionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UnlabelParameterVersionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UnlabelParameterVersionRequest(_a0 *ssm.UnlabelParameterVersionInput) (*request.Request, *ssm.UnlabelParameterVersionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UnlabelParameterVersionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UnlabelParameterVersionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UnlabelParameterVersionInput) *ssm.UnlabelParameterVersionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UnlabelParameterVersionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UnlabelParameterVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UnlabelParameterVersionWithContext(_a0 context.Context, _a1 *ssm.UnlabelParameterVersionInput, _a2 ...request.Option) (*ssm.UnlabelParameterVersionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UnlabelParameterVersionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UnlabelParameterVersionInput, ...request.Option) *ssm.UnlabelParameterVersionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UnlabelParameterVersionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UnlabelParameterVersionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateAssociation provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateAssociation(_a0 *ssm.UpdateAssociationInput) (*ssm.UpdateAssociationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateAssociationOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationInput) *ssm.UpdateAssociationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateAssociationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateAssociationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateAssociationRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateAssociationRequest(_a0 *ssm.UpdateAssociationInput) (*request.Request, *ssm.UpdateAssociationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateAssociationOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateAssociationInput) *ssm.UpdateAssociationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateAssociationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateAssociationStatus provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateAssociationStatus(_a0 *ssm.UpdateAssociationStatusInput) (*ssm.UpdateAssociationStatusOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateAssociationStatusOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationStatusInput) *ssm.UpdateAssociationStatusOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateAssociationStatusOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateAssociationStatusInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateAssociationStatusRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateAssociationStatusRequest(_a0 *ssm.UpdateAssociationStatusInput) (*request.Request, *ssm.UpdateAssociationStatusOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateAssociationStatusInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateAssociationStatusOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateAssociationStatusInput) *ssm.UpdateAssociationStatusOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateAssociationStatusOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateAssociationStatusWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateAssociationStatusWithContext(_a0 context.Context, _a1 *ssm.UpdateAssociationStatusInput, _a2 ...request.Option) (*ssm.UpdateAssociationStatusOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateAssociationStatusOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateAssociationStatusInput, ...request.Option) *ssm.UpdateAssociationStatusOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateAssociationStatusOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateAssociationStatusInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateAssociationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateAssociationWithContext(_a0 context.Context, _a1 *ssm.UpdateAssociationInput, _a2 ...request.Option) (*ssm.UpdateAssociationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateAssociationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateAssociationInput, ...request.Option) *ssm.UpdateAssociationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateAssociationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateAssociationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateDocument provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateDocument(_a0 *ssm.UpdateDocumentInput) (*ssm.UpdateDocumentOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateDocumentOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentInput) *ssm.UpdateDocumentOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateDocumentInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateDocumentDefaultVersion provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateDocumentDefaultVersion(_a0 *ssm.UpdateDocumentDefaultVersionInput) (*ssm.UpdateDocumentDefaultVersionOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateDocumentDefaultVersionOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentDefaultVersionInput) *ssm.UpdateDocumentDefaultVersionOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateDocumentDefaultVersionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateDocumentDefaultVersionInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateDocumentDefaultVersionRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateDocumentDefaultVersionRequest(_a0 *ssm.UpdateDocumentDefaultVersionInput) (*request.Request, *ssm.UpdateDocumentDefaultVersionOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentDefaultVersionInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateDocumentDefaultVersionOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateDocumentDefaultVersionInput) *ssm.UpdateDocumentDefaultVersionOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateDocumentDefaultVersionOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateDocumentDefaultVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateDocumentDefaultVersionWithContext(_a0 context.Context, _a1 *ssm.UpdateDocumentDefaultVersionInput, _a2 ...request.Option) (*ssm.UpdateDocumentDefaultVersionOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateDocumentDefaultVersionOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateDocumentDefaultVersionInput, ...request.Option) *ssm.UpdateDocumentDefaultVersionOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateDocumentDefaultVersionOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateDocumentDefaultVersionInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateDocumentMetadata provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateDocumentMetadata(_a0 *ssm.UpdateDocumentMetadataInput) (*ssm.UpdateDocumentMetadataOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateDocumentMetadataOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentMetadataInput) *ssm.UpdateDocumentMetadataOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateDocumentMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateDocumentMetadataInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateDocumentMetadataRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateDocumentMetadataRequest(_a0 *ssm.UpdateDocumentMetadataInput) (*request.Request, *ssm.UpdateDocumentMetadataOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentMetadataInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateDocumentMetadataOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateDocumentMetadataInput) *ssm.UpdateDocumentMetadataOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateDocumentMetadataOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateDocumentMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateDocumentMetadataWithContext(_a0 context.Context, _a1 *ssm.UpdateDocumentMetadataInput, _a2 ...request.Option) (*ssm.UpdateDocumentMetadataOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateDocumentMetadataOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateDocumentMetadataInput, ...request.Option) *ssm.UpdateDocumentMetadataOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateDocumentMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateDocumentMetadataInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateDocumentRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateDocumentRequest(_a0 *ssm.UpdateDocumentInput) (*request.Request, *ssm.UpdateDocumentOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateDocumentInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateDocumentOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateDocumentInput) *ssm.UpdateDocumentOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateDocumentOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateDocumentWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateDocumentWithContext(_a0 context.Context, _a1 *ssm.UpdateDocumentInput, _a2 ...request.Option) (*ssm.UpdateDocumentOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateDocumentOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateDocumentInput, ...request.Option) *ssm.UpdateDocumentOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateDocumentOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateDocumentInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindow provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateMaintenanceWindow(_a0 *ssm.UpdateMaintenanceWindowInput) (*ssm.UpdateMaintenanceWindowOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowInput) *ssm.UpdateMaintenanceWindowOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindowRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateMaintenanceWindowRequest(_a0 *ssm.UpdateMaintenanceWindowInput) (*request.Request, *ssm.UpdateMaintenanceWindowOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateMaintenanceWindowOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowInput) *ssm.UpdateMaintenanceWindowOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateMaintenanceWindowOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindowTarget provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateMaintenanceWindowTarget(_a0 *ssm.UpdateMaintenanceWindowTargetInput) (*ssm.UpdateMaintenanceWindowTargetOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateMaintenanceWindowTargetOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTargetInput) *ssm.UpdateMaintenanceWindowTargetOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTargetOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowTargetInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindowTargetRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateMaintenanceWindowTargetRequest(_a0 *ssm.UpdateMaintenanceWindowTargetInput) (*request.Request, *ssm.UpdateMaintenanceWindowTargetOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTargetInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateMaintenanceWindowTargetOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowTargetInput) *ssm.UpdateMaintenanceWindowTargetOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateMaintenanceWindowTargetOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindowTargetWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateMaintenanceWindowTargetWithContext(_a0 context.Context, _a1 *ssm.UpdateMaintenanceWindowTargetInput, _a2 ...request.Option) (*ssm.UpdateMaintenanceWindowTargetOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateMaintenanceWindowTargetOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateMaintenanceWindowTargetInput, ...request.Option) *ssm.UpdateMaintenanceWindowTargetOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTargetOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateMaintenanceWindowTargetInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindowTask provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateMaintenanceWindowTask(_a0 *ssm.UpdateMaintenanceWindowTaskInput) (*ssm.UpdateMaintenanceWindowTaskOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateMaintenanceWindowTaskOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTaskInput) *ssm.UpdateMaintenanceWindowTaskOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTaskOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowTaskInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindowTaskRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateMaintenanceWindowTaskRequest(_a0 *ssm.UpdateMaintenanceWindowTaskInput) (*request.Request, *ssm.UpdateMaintenanceWindowTaskOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateMaintenanceWindowTaskInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateMaintenanceWindowTaskOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateMaintenanceWindowTaskInput) *ssm.UpdateMaintenanceWindowTaskOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateMaintenanceWindowTaskOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindowTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateMaintenanceWindowTaskWithContext(_a0 context.Context, _a1 *ssm.UpdateMaintenanceWindowTaskInput, _a2 ...request.Option) (*ssm.UpdateMaintenanceWindowTaskOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateMaintenanceWindowTaskOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateMaintenanceWindowTaskInput, ...request.Option) *ssm.UpdateMaintenanceWindowTaskOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowTaskOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateMaintenanceWindowTaskInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateMaintenanceWindowWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateMaintenanceWindowWithContext(_a0 context.Context, _a1 *ssm.UpdateMaintenanceWindowInput, _a2 ...request.Option) (*ssm.UpdateMaintenanceWindowOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateMaintenanceWindowOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateMaintenanceWindowInput, ...request.Option) *ssm.UpdateMaintenanceWindowOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateMaintenanceWindowOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateMaintenanceWindowInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateManagedInstanceRole provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateManagedInstanceRole(_a0 *ssm.UpdateManagedInstanceRoleInput) (*ssm.UpdateManagedInstanceRoleOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateManagedInstanceRoleOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateManagedInstanceRoleInput) *ssm.UpdateManagedInstanceRoleOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateManagedInstanceRoleOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateManagedInstanceRoleInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateManagedInstanceRoleRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateManagedInstanceRoleRequest(_a0 *ssm.UpdateManagedInstanceRoleInput) (*request.Request, *ssm.UpdateManagedInstanceRoleOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateManagedInstanceRoleInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateManagedInstanceRoleOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateManagedInstanceRoleInput) *ssm.UpdateManagedInstanceRoleOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateManagedInstanceRoleOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateManagedInstanceRoleWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateManagedInstanceRoleWithContext(_a0 context.Context, _a1 *ssm.UpdateManagedInstanceRoleInput, _a2 ...request.Option) (*ssm.UpdateManagedInstanceRoleOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateManagedInstanceRoleOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateManagedInstanceRoleInput, ...request.Option) *ssm.UpdateManagedInstanceRoleOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateManagedInstanceRoleOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateManagedInstanceRoleInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateOpsItem provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateOpsItem(_a0 *ssm.UpdateOpsItemInput) (*ssm.UpdateOpsItemOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateOpsItemOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateOpsItemInput) *ssm.UpdateOpsItemOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateOpsItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateOpsItemInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateOpsItemRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateOpsItemRequest(_a0 *ssm.UpdateOpsItemInput) (*request.Request, *ssm.UpdateOpsItemOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateOpsItemInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateOpsItemOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateOpsItemInput) *ssm.UpdateOpsItemOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateOpsItemOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateOpsItemWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateOpsItemWithContext(_a0 context.Context, _a1 *ssm.UpdateOpsItemInput, _a2 ...request.Option) (*ssm.UpdateOpsItemOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateOpsItemOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateOpsItemInput, ...request.Option) *ssm.UpdateOpsItemOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateOpsItemOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateOpsItemInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateOpsMetadata provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateOpsMetadata(_a0 *ssm.UpdateOpsMetadataInput) (*ssm.UpdateOpsMetadataOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateOpsMetadataInput) *ssm.UpdateOpsMetadataOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateOpsMetadataInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateOpsMetadataRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateOpsMetadataRequest(_a0 *ssm.UpdateOpsMetadataInput) (*request.Request, *ssm.UpdateOpsMetadataOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateOpsMetadataInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateOpsMetadataOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateOpsMetadataInput) *ssm.UpdateOpsMetadataOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateOpsMetadataOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateOpsMetadataWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateOpsMetadataWithContext(_a0 context.Context, _a1 *ssm.UpdateOpsMetadataInput, _a2 ...request.Option) (*ssm.UpdateOpsMetadataOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateOpsMetadataOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateOpsMetadataInput, ...request.Option) *ssm.UpdateOpsMetadataOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateOpsMetadataOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateOpsMetadataInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdatePatchBaseline provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdatePatchBaseline(_a0 *ssm.UpdatePatchBaselineInput) (*ssm.UpdatePatchBaselineOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdatePatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdatePatchBaselineInput) *ssm.UpdatePatchBaselineOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdatePatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdatePatchBaselineInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdatePatchBaselineRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdatePatchBaselineRequest(_a0 *ssm.UpdatePatchBaselineInput) (*request.Request, *ssm.UpdatePatchBaselineOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdatePatchBaselineInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdatePatchBaselineOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdatePatchBaselineInput) *ssm.UpdatePatchBaselineOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdatePatchBaselineOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdatePatchBaselineWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdatePatchBaselineWithContext(_a0 context.Context, _a1 *ssm.UpdatePatchBaselineInput, _a2 ...request.Option) (*ssm.UpdatePatchBaselineOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdatePatchBaselineOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdatePatchBaselineInput, ...request.Option) *ssm.UpdatePatchBaselineOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdatePatchBaselineOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdatePatchBaselineInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateResourceDataSync provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateResourceDataSync(_a0 *ssm.UpdateResourceDataSyncInput) (*ssm.UpdateResourceDataSyncOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateResourceDataSyncOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateResourceDataSyncInput) *ssm.UpdateResourceDataSyncOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateResourceDataSyncOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateResourceDataSyncInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateResourceDataSyncRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateResourceDataSyncRequest(_a0 *ssm.UpdateResourceDataSyncInput) (*request.Request, *ssm.UpdateResourceDataSyncOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateResourceDataSyncInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateResourceDataSyncOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateResourceDataSyncInput) *ssm.UpdateResourceDataSyncOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateResourceDataSyncOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateResourceDataSyncWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateResourceDataSyncWithContext(_a0 context.Context, _a1 *ssm.UpdateResourceDataSyncInput, _a2 ...request.Option) (*ssm.UpdateResourceDataSyncOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateResourceDataSyncOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateResourceDataSyncInput, ...request.Option) *ssm.UpdateResourceDataSyncOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateResourceDataSyncOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateResourceDataSyncInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateServiceSetting provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateServiceSetting(_a0 *ssm.UpdateServiceSettingInput) (*ssm.UpdateServiceSettingOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *ssm.UpdateServiceSettingOutput
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateServiceSettingInput) *ssm.UpdateServiceSettingOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateServiceSettingOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateServiceSettingInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateServiceSettingRequest provides a mock function with given fields: _a0
-func (_m *SSMAPI) UpdateServiceSettingRequest(_a0 *ssm.UpdateServiceSettingInput) (*request.Request, *ssm.UpdateServiceSettingOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*ssm.UpdateServiceSettingInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *ssm.UpdateServiceSettingOutput
-	if rf, ok := ret.Get(1).(func(*ssm.UpdateServiceSettingInput) *ssm.UpdateServiceSettingOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*ssm.UpdateServiceSettingOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateServiceSettingWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) UpdateServiceSettingWithContext(_a0 context.Context, _a1 *ssm.UpdateServiceSettingInput, _a2 ...request.Option) (*ssm.UpdateServiceSettingOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *ssm.UpdateServiceSettingOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.UpdateServiceSettingInput, ...request.Option) *ssm.UpdateServiceSettingOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*ssm.UpdateServiceSettingOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *ssm.UpdateServiceSettingInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// WaitUntilCommandExecuted provides a mock function with given fields: _a0
-func (_m *SSMAPI) WaitUntilCommandExecuted(_a0 *ssm.GetCommandInvocationInput) error {
-	ret := _m.Called(_a0)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*ssm.GetCommandInvocationInput) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// WaitUntilCommandExecutedWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SSMAPI) WaitUntilCommandExecutedWithContext(_a0 context.Context, _a1 *ssm.GetCommandInvocationInput, _a2 ...request.WaiterOption) error {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *ssm.GetCommandInvocationInput, ...request.WaiterOption) error); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-type mockConstructorTestingTNewSSMAPI interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewSSMAPI creates a new instance of SSMAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewSSMAPI(t mockConstructorTestingTNewSSMAPI) *SSMAPI {
-	mock := &SSMAPI{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
+func (_c *SSMAPI_GetParameter_Call) RunAndReturn(run func(context1 context.Context, getParameterInput *ssm.GetParameterInput, fns ...func(*ssm.Options)) (*ssm.GetParameterOutput, error)) *SSMAPI_GetParameter_Call {
+	_c.Call.Return(run)
+	return _c
 }
diff --git a/mocks/SecretsManagerAPI.go b/mocks/SecretsManagerAPI.go
index 0cd4a0c..7454295 100644
--- a/mocks/SecretsManagerAPI.go
+++ b/mocks/SecretsManagerAPI.go
@@ -1,1818 +1,122 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
 
 package mocks
 
 import (
-	context "context"
+	"context"
 
-	request "github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
 	mock "github.com/stretchr/testify/mock"
-
-	secretsmanager "github.com/aws/aws-sdk-go/service/secretsmanager"
 )
 
-// SecretsManagerAPI is an autogenerated mock type for the SecretsManagerAPI type
-type SecretsManagerAPI struct {
-	mock.Mock
-}
-
-// CancelRotateSecret provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) CancelRotateSecret(_a0 *secretsmanager.CancelRotateSecretInput) (*secretsmanager.CancelRotateSecretOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.CancelRotateSecretOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.CancelRotateSecretInput) *secretsmanager.CancelRotateSecretOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.CancelRotateSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.CancelRotateSecretInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CancelRotateSecretRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) CancelRotateSecretRequest(_a0 *secretsmanager.CancelRotateSecretInput) (*request.Request, *secretsmanager.CancelRotateSecretOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.CancelRotateSecretInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.CancelRotateSecretOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.CancelRotateSecretInput) *secretsmanager.CancelRotateSecretOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.CancelRotateSecretOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CancelRotateSecretWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) CancelRotateSecretWithContext(_a0 context.Context, _a1 *secretsmanager.CancelRotateSecretInput, _a2 ...request.Option) (*secretsmanager.CancelRotateSecretOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.CancelRotateSecretOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.CancelRotateSecretInput, ...request.Option) *secretsmanager.CancelRotateSecretOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.CancelRotateSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.CancelRotateSecretInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateSecret provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) CreateSecret(_a0 *secretsmanager.CreateSecretInput) (*secretsmanager.CreateSecretOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.CreateSecretOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.CreateSecretInput) *secretsmanager.CreateSecretOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.CreateSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.CreateSecretInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// CreateSecretRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) CreateSecretRequest(_a0 *secretsmanager.CreateSecretInput) (*request.Request, *secretsmanager.CreateSecretOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.CreateSecretInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.CreateSecretOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.CreateSecretInput) *secretsmanager.CreateSecretOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.CreateSecretOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// CreateSecretWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) CreateSecretWithContext(_a0 context.Context, _a1 *secretsmanager.CreateSecretInput, _a2 ...request.Option) (*secretsmanager.CreateSecretOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.CreateSecretOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.CreateSecretInput, ...request.Option) *secretsmanager.CreateSecretOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.CreateSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.CreateSecretInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// DeleteResourcePolicy provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) DeleteResourcePolicy(_a0 *secretsmanager.DeleteResourcePolicyInput) (*secretsmanager.DeleteResourcePolicyOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.DeleteResourcePolicyOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.DeleteResourcePolicyInput) *secretsmanager.DeleteResourcePolicyOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.DeleteResourcePolicyOutput)
-		}
-	}
+// NewSecretsManagerAPI creates a new instance of SecretsManagerAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewSecretsManagerAPI(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *SecretsManagerAPI {
+	mock := &SecretsManagerAPI{}
+	mock.Mock.Test(t)
 
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.DeleteResourcePolicyInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
+	t.Cleanup(func() { mock.AssertExpectations(t) })
 
-	return r0, r1
+	return mock
 }
 
-// DeleteResourcePolicyRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) DeleteResourcePolicyRequest(_a0 *secretsmanager.DeleteResourcePolicyInput) (*request.Request, *secretsmanager.DeleteResourcePolicyOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.DeleteResourcePolicyInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.DeleteResourcePolicyOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.DeleteResourcePolicyInput) *secretsmanager.DeleteResourcePolicyOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.DeleteResourcePolicyOutput)
-		}
-	}
-
-	return r0, r1
+// SecretsManagerAPI is an autogenerated mock type for the SecretsManagerAPI type
+type SecretsManagerAPI struct {
+	mock.Mock
 }
 
-// DeleteResourcePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) DeleteResourcePolicyWithContext(_a0 context.Context, _a1 *secretsmanager.DeleteResourcePolicyInput, _a2 ...request.Option) (*secretsmanager.DeleteResourcePolicyOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.DeleteResourcePolicyOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.DeleteResourcePolicyInput, ...request.Option) *secretsmanager.DeleteResourcePolicyOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.DeleteResourcePolicyOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.DeleteResourcePolicyInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+type SecretsManagerAPI_Expecter struct {
+	mock *mock.Mock
 }
 
-// DeleteSecret provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) DeleteSecret(_a0 *secretsmanager.DeleteSecretInput) (*secretsmanager.DeleteSecretOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.DeleteSecretOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.DeleteSecretInput) *secretsmanager.DeleteSecretOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.DeleteSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.DeleteSecretInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+func (_m *SecretsManagerAPI) EXPECT() *SecretsManagerAPI_Expecter {
+	return &SecretsManagerAPI_Expecter{mock: &_m.Mock}
 }
 
-// DeleteSecretRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) DeleteSecretRequest(_a0 *secretsmanager.DeleteSecretInput) (*request.Request, *secretsmanager.DeleteSecretOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.DeleteSecretInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.DeleteSecretOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.DeleteSecretInput) *secretsmanager.DeleteSecretOutput); ok {
-		r1 = rf(_a0)
+// GetSecretValue provides a mock function for the type SecretsManagerAPI
+func (_mock *SecretsManagerAPI) GetSecretValue(context1 context.Context, getSecretValueInput *secretsmanager.GetSecretValueInput, fns ...func(*secretsmanager.Options)) (*secretsmanager.GetSecretValueOutput, error) {
+	var tmpRet mock.Arguments
+	if len(fns) > 0 {
+		tmpRet = _mock.Called(context1, getSecretValueInput, fns)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.DeleteSecretOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// DeleteSecretWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) DeleteSecretWithContext(_a0 context.Context, _a1 *secretsmanager.DeleteSecretInput, _a2 ...request.Option) (*secretsmanager.DeleteSecretOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
+		tmpRet = _mock.Called(context1, getSecretValueInput)
 	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
+	ret := tmpRet
 
-	var r0 *secretsmanager.DeleteSecretOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.DeleteSecretInput, ...request.Option) *secretsmanager.DeleteSecretOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.DeleteSecretOutput)
-		}
+	if len(ret) == 0 {
+		panic("no return value specified for GetSecretValue")
 	}
 
+	var r0 *secretsmanager.GetSecretValueOutput
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.DeleteSecretInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *secretsmanager.GetSecretValueInput, ...func(*secretsmanager.Options)) (*secretsmanager.GetSecretValueOutput, error)); ok {
+		return returnFunc(context1, getSecretValueInput, fns...)
 	}
-
-	return r0, r1
-}
-
-// DescribeSecret provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) DescribeSecret(_a0 *secretsmanager.DescribeSecretInput) (*secretsmanager.DescribeSecretOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.DescribeSecretOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.DescribeSecretInput) *secretsmanager.DescribeSecretOutput); ok {
-		r0 = rf(_a0)
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *secretsmanager.GetSecretValueInput, ...func(*secretsmanager.Options)) *secretsmanager.GetSecretValueOutput); ok {
+		r0 = returnFunc(context1, getSecretValueInput, fns...)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.DescribeSecretOutput)
+			r0 = ret.Get(0).(*secretsmanager.GetSecretValueOutput)
 		}
 	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.DescribeSecretInput) error); ok {
-		r1 = rf(_a0)
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *secretsmanager.GetSecretValueInput, ...func(*secretsmanager.Options)) error); ok {
+		r1 = returnFunc(context1, getSecretValueInput, fns...)
 	} else {
 		r1 = ret.Error(1)
 	}
-
-	return r0, r1
-}
-
-// DescribeSecretRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) DescribeSecretRequest(_a0 *secretsmanager.DescribeSecretInput) (*request.Request, *secretsmanager.DescribeSecretOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.DescribeSecretInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.DescribeSecretOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.DescribeSecretInput) *secretsmanager.DescribeSecretOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.DescribeSecretOutput)
-		}
-	}
-
 	return r0, r1
 }
 
-// DescribeSecretWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) DescribeSecretWithContext(_a0 context.Context, _a1 *secretsmanager.DescribeSecretInput, _a2 ...request.Option) (*secretsmanager.DescribeSecretOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.DescribeSecretOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.DescribeSecretInput, ...request.Option) *secretsmanager.DescribeSecretOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.DescribeSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.DescribeSecretInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+// SecretsManagerAPI_GetSecretValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecretValue'
+type SecretsManagerAPI_GetSecretValue_Call struct {
+	*mock.Call
 }
 
-// GetRandomPassword provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) GetRandomPassword(_a0 *secretsmanager.GetRandomPasswordInput) (*secretsmanager.GetRandomPasswordOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.GetRandomPasswordOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.GetRandomPasswordInput) *secretsmanager.GetRandomPasswordOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.GetRandomPasswordOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.GetRandomPasswordInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+// GetSecretValue is a helper method to define mock.On call
+//   - context1 context.Context
+//   - getSecretValueInput *secretsmanager.GetSecretValueInput
+//   - fns ...func(*secretsmanager.Options)
+func (_e *SecretsManagerAPI_Expecter) GetSecretValue(context1 any, getSecretValueInput any, fns ...any) *SecretsManagerAPI_GetSecretValue_Call {
+	return &SecretsManagerAPI_GetSecretValue_Call{Call: _e.mock.On("GetSecretValue",
+		append([]any{context1, getSecretValueInput}, fns...)...)}
 }
 
-// GetRandomPasswordRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) GetRandomPasswordRequest(_a0 *secretsmanager.GetRandomPasswordInput) (*request.Request, *secretsmanager.GetRandomPasswordOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.GetRandomPasswordInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
+func (_c *SecretsManagerAPI_GetSecretValue_Call) Run(run func(context1 context.Context, getSecretValueInput *secretsmanager.GetSecretValueInput, fns ...func(*secretsmanager.Options))) *SecretsManagerAPI_GetSecretValue_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
 		}
-	}
-
-	var r1 *secretsmanager.GetRandomPasswordOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.GetRandomPasswordInput) *secretsmanager.GetRandomPasswordOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.GetRandomPasswordOutput)
+		var arg1 *secretsmanager.GetSecretValueInput
+		if args[1] != nil {
+			arg1 = args[1].(*secretsmanager.GetSecretValueInput)
 		}
-	}
-
-	return r0, r1
-}
-
-// GetRandomPasswordWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) GetRandomPasswordWithContext(_a0 context.Context, _a1 *secretsmanager.GetRandomPasswordInput, _a2 ...request.Option) (*secretsmanager.GetRandomPasswordOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.GetRandomPasswordOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.GetRandomPasswordInput, ...request.Option) *secretsmanager.GetRandomPasswordOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.GetRandomPasswordOutput)
+		var arg2 []func(*secretsmanager.Options)
+		var variadicArgs []func(*secretsmanager.Options)
+		if len(args) > 2 {
+			variadicArgs = args[2].([]func(*secretsmanager.Options))
 		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.GetRandomPasswordInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
 }
 
-// GetResourcePolicy provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) GetResourcePolicy(_a0 *secretsmanager.GetResourcePolicyInput) (*secretsmanager.GetResourcePolicyOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.GetResourcePolicyOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.GetResourcePolicyInput) *secretsmanager.GetResourcePolicyOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.GetResourcePolicyOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.GetResourcePolicyInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+func (_c *SecretsManagerAPI_GetSecretValue_Call) Return(getSecretValueOutput *secretsmanager.GetSecretValueOutput, err error) *SecretsManagerAPI_GetSecretValue_Call {
+	_c.Call.Return(getSecretValueOutput, err)
+	return _c
 }
 
-// GetResourcePolicyRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) GetResourcePolicyRequest(_a0 *secretsmanager.GetResourcePolicyInput) (*request.Request, *secretsmanager.GetResourcePolicyOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.GetResourcePolicyInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.GetResourcePolicyOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.GetResourcePolicyInput) *secretsmanager.GetResourcePolicyOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.GetResourcePolicyOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetResourcePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) GetResourcePolicyWithContext(_a0 context.Context, _a1 *secretsmanager.GetResourcePolicyInput, _a2 ...request.Option) (*secretsmanager.GetResourcePolicyOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.GetResourcePolicyOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.GetResourcePolicyInput, ...request.Option) *secretsmanager.GetResourcePolicyOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.GetResourcePolicyOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.GetResourcePolicyInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetSecretValue provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) GetSecretValue(_a0 *secretsmanager.GetSecretValueInput) (*secretsmanager.GetSecretValueOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.GetSecretValueOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.GetSecretValueInput) *secretsmanager.GetSecretValueOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.GetSecretValueOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.GetSecretValueInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// GetSecretValueRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) GetSecretValueRequest(_a0 *secretsmanager.GetSecretValueInput) (*request.Request, *secretsmanager.GetSecretValueOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.GetSecretValueInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.GetSecretValueOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.GetSecretValueInput) *secretsmanager.GetSecretValueOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.GetSecretValueOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// GetSecretValueWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) GetSecretValueWithContext(_a0 context.Context, _a1 *secretsmanager.GetSecretValueInput, _a2 ...request.Option) (*secretsmanager.GetSecretValueOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.GetSecretValueOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.GetSecretValueInput, ...request.Option) *secretsmanager.GetSecretValueOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.GetSecretValueOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.GetSecretValueInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListSecretVersionIds provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) ListSecretVersionIds(_a0 *secretsmanager.ListSecretVersionIdsInput) (*secretsmanager.ListSecretVersionIdsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.ListSecretVersionIdsOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ListSecretVersionIdsInput) *secretsmanager.ListSecretVersionIdsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.ListSecretVersionIdsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.ListSecretVersionIdsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListSecretVersionIdsPages provides a mock function with given fields: _a0, _a1
-func (_m *SecretsManagerAPI) ListSecretVersionIdsPages(_a0 *secretsmanager.ListSecretVersionIdsInput, _a1 func(*secretsmanager.ListSecretVersionIdsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ListSecretVersionIdsInput, func(*secretsmanager.ListSecretVersionIdsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListSecretVersionIdsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SecretsManagerAPI) ListSecretVersionIdsPagesWithContext(_a0 context.Context, _a1 *secretsmanager.ListSecretVersionIdsInput, _a2 func(*secretsmanager.ListSecretVersionIdsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.ListSecretVersionIdsInput, func(*secretsmanager.ListSecretVersionIdsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListSecretVersionIdsRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) ListSecretVersionIdsRequest(_a0 *secretsmanager.ListSecretVersionIdsInput) (*request.Request, *secretsmanager.ListSecretVersionIdsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ListSecretVersionIdsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.ListSecretVersionIdsOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.ListSecretVersionIdsInput) *secretsmanager.ListSecretVersionIdsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.ListSecretVersionIdsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListSecretVersionIdsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) ListSecretVersionIdsWithContext(_a0 context.Context, _a1 *secretsmanager.ListSecretVersionIdsInput, _a2 ...request.Option) (*secretsmanager.ListSecretVersionIdsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.ListSecretVersionIdsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.ListSecretVersionIdsInput, ...request.Option) *secretsmanager.ListSecretVersionIdsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.ListSecretVersionIdsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.ListSecretVersionIdsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListSecrets provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) ListSecrets(_a0 *secretsmanager.ListSecretsInput) (*secretsmanager.ListSecretsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.ListSecretsOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ListSecretsInput) *secretsmanager.ListSecretsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.ListSecretsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.ListSecretsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ListSecretsPages provides a mock function with given fields: _a0, _a1
-func (_m *SecretsManagerAPI) ListSecretsPages(_a0 *secretsmanager.ListSecretsInput, _a1 func(*secretsmanager.ListSecretsOutput, bool) bool) error {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ListSecretsInput, func(*secretsmanager.ListSecretsOutput, bool) bool) error); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListSecretsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *SecretsManagerAPI) ListSecretsPagesWithContext(_a0 context.Context, _a1 *secretsmanager.ListSecretsInput, _a2 func(*secretsmanager.ListSecretsOutput, bool) bool, _a3 ...request.Option) error {
-	_va := make([]interface{}, len(_a3))
-	for _i := range _a3 {
-		_va[_i] = _a3[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1, _a2)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.ListSecretsInput, func(*secretsmanager.ListSecretsOutput, bool) bool, ...request.Option) error); ok {
-		r0 = rf(_a0, _a1, _a2, _a3...)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// ListSecretsRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) ListSecretsRequest(_a0 *secretsmanager.ListSecretsInput) (*request.Request, *secretsmanager.ListSecretsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ListSecretsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.ListSecretsOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.ListSecretsInput) *secretsmanager.ListSecretsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.ListSecretsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ListSecretsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) ListSecretsWithContext(_a0 context.Context, _a1 *secretsmanager.ListSecretsInput, _a2 ...request.Option) (*secretsmanager.ListSecretsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.ListSecretsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.ListSecretsInput, ...request.Option) *secretsmanager.ListSecretsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.ListSecretsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.ListSecretsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutResourcePolicy provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) PutResourcePolicy(_a0 *secretsmanager.PutResourcePolicyInput) (*secretsmanager.PutResourcePolicyOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.PutResourcePolicyOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.PutResourcePolicyInput) *secretsmanager.PutResourcePolicyOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.PutResourcePolicyOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.PutResourcePolicyInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutResourcePolicyRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) PutResourcePolicyRequest(_a0 *secretsmanager.PutResourcePolicyInput) (*request.Request, *secretsmanager.PutResourcePolicyOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.PutResourcePolicyInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.PutResourcePolicyOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.PutResourcePolicyInput) *secretsmanager.PutResourcePolicyOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.PutResourcePolicyOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// PutResourcePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) PutResourcePolicyWithContext(_a0 context.Context, _a1 *secretsmanager.PutResourcePolicyInput, _a2 ...request.Option) (*secretsmanager.PutResourcePolicyOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.PutResourcePolicyOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.PutResourcePolicyInput, ...request.Option) *secretsmanager.PutResourcePolicyOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.PutResourcePolicyOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.PutResourcePolicyInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutSecretValue provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) PutSecretValue(_a0 *secretsmanager.PutSecretValueInput) (*secretsmanager.PutSecretValueOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.PutSecretValueOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.PutSecretValueInput) *secretsmanager.PutSecretValueOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.PutSecretValueOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.PutSecretValueInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// PutSecretValueRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) PutSecretValueRequest(_a0 *secretsmanager.PutSecretValueInput) (*request.Request, *secretsmanager.PutSecretValueOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.PutSecretValueInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.PutSecretValueOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.PutSecretValueInput) *secretsmanager.PutSecretValueOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.PutSecretValueOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// PutSecretValueWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) PutSecretValueWithContext(_a0 context.Context, _a1 *secretsmanager.PutSecretValueInput, _a2 ...request.Option) (*secretsmanager.PutSecretValueOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.PutSecretValueOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.PutSecretValueInput, ...request.Option) *secretsmanager.PutSecretValueOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.PutSecretValueOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.PutSecretValueInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RemoveRegionsFromReplication provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) RemoveRegionsFromReplication(_a0 *secretsmanager.RemoveRegionsFromReplicationInput) (*secretsmanager.RemoveRegionsFromReplicationOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.RemoveRegionsFromReplicationOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.RemoveRegionsFromReplicationInput) *secretsmanager.RemoveRegionsFromReplicationOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.RemoveRegionsFromReplicationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.RemoveRegionsFromReplicationInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RemoveRegionsFromReplicationRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) RemoveRegionsFromReplicationRequest(_a0 *secretsmanager.RemoveRegionsFromReplicationInput) (*request.Request, *secretsmanager.RemoveRegionsFromReplicationOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.RemoveRegionsFromReplicationInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.RemoveRegionsFromReplicationOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.RemoveRegionsFromReplicationInput) *secretsmanager.RemoveRegionsFromReplicationOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.RemoveRegionsFromReplicationOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// RemoveRegionsFromReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) RemoveRegionsFromReplicationWithContext(_a0 context.Context, _a1 *secretsmanager.RemoveRegionsFromReplicationInput, _a2 ...request.Option) (*secretsmanager.RemoveRegionsFromReplicationOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.RemoveRegionsFromReplicationOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.RemoveRegionsFromReplicationInput, ...request.Option) *secretsmanager.RemoveRegionsFromReplicationOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.RemoveRegionsFromReplicationOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.RemoveRegionsFromReplicationInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ReplicateSecretToRegions provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) ReplicateSecretToRegions(_a0 *secretsmanager.ReplicateSecretToRegionsInput) (*secretsmanager.ReplicateSecretToRegionsOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.ReplicateSecretToRegionsOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ReplicateSecretToRegionsInput) *secretsmanager.ReplicateSecretToRegionsOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.ReplicateSecretToRegionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.ReplicateSecretToRegionsInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ReplicateSecretToRegionsRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) ReplicateSecretToRegionsRequest(_a0 *secretsmanager.ReplicateSecretToRegionsInput) (*request.Request, *secretsmanager.ReplicateSecretToRegionsOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ReplicateSecretToRegionsInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.ReplicateSecretToRegionsOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.ReplicateSecretToRegionsInput) *secretsmanager.ReplicateSecretToRegionsOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.ReplicateSecretToRegionsOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ReplicateSecretToRegionsWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) ReplicateSecretToRegionsWithContext(_a0 context.Context, _a1 *secretsmanager.ReplicateSecretToRegionsInput, _a2 ...request.Option) (*secretsmanager.ReplicateSecretToRegionsOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.ReplicateSecretToRegionsOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.ReplicateSecretToRegionsInput, ...request.Option) *secretsmanager.ReplicateSecretToRegionsOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.ReplicateSecretToRegionsOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.ReplicateSecretToRegionsInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RestoreSecret provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) RestoreSecret(_a0 *secretsmanager.RestoreSecretInput) (*secretsmanager.RestoreSecretOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.RestoreSecretOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.RestoreSecretInput) *secretsmanager.RestoreSecretOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.RestoreSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.RestoreSecretInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RestoreSecretRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) RestoreSecretRequest(_a0 *secretsmanager.RestoreSecretInput) (*request.Request, *secretsmanager.RestoreSecretOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.RestoreSecretInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.RestoreSecretOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.RestoreSecretInput) *secretsmanager.RestoreSecretOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.RestoreSecretOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// RestoreSecretWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) RestoreSecretWithContext(_a0 context.Context, _a1 *secretsmanager.RestoreSecretInput, _a2 ...request.Option) (*secretsmanager.RestoreSecretOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.RestoreSecretOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.RestoreSecretInput, ...request.Option) *secretsmanager.RestoreSecretOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.RestoreSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.RestoreSecretInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RotateSecret provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) RotateSecret(_a0 *secretsmanager.RotateSecretInput) (*secretsmanager.RotateSecretOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.RotateSecretOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.RotateSecretInput) *secretsmanager.RotateSecretOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.RotateSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.RotateSecretInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// RotateSecretRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) RotateSecretRequest(_a0 *secretsmanager.RotateSecretInput) (*request.Request, *secretsmanager.RotateSecretOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.RotateSecretInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.RotateSecretOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.RotateSecretInput) *secretsmanager.RotateSecretOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.RotateSecretOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// RotateSecretWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) RotateSecretWithContext(_a0 context.Context, _a1 *secretsmanager.RotateSecretInput, _a2 ...request.Option) (*secretsmanager.RotateSecretOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.RotateSecretOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.RotateSecretInput, ...request.Option) *secretsmanager.RotateSecretOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.RotateSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.RotateSecretInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StopReplicationToReplica provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) StopReplicationToReplica(_a0 *secretsmanager.StopReplicationToReplicaInput) (*secretsmanager.StopReplicationToReplicaOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.StopReplicationToReplicaOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.StopReplicationToReplicaInput) *secretsmanager.StopReplicationToReplicaOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.StopReplicationToReplicaOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.StopReplicationToReplicaInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// StopReplicationToReplicaRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) StopReplicationToReplicaRequest(_a0 *secretsmanager.StopReplicationToReplicaInput) (*request.Request, *secretsmanager.StopReplicationToReplicaOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.StopReplicationToReplicaInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.StopReplicationToReplicaOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.StopReplicationToReplicaInput) *secretsmanager.StopReplicationToReplicaOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.StopReplicationToReplicaOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// StopReplicationToReplicaWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) StopReplicationToReplicaWithContext(_a0 context.Context, _a1 *secretsmanager.StopReplicationToReplicaInput, _a2 ...request.Option) (*secretsmanager.StopReplicationToReplicaOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.StopReplicationToReplicaOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.StopReplicationToReplicaInput, ...request.Option) *secretsmanager.StopReplicationToReplicaOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.StopReplicationToReplicaOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.StopReplicationToReplicaInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// TagResource provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) TagResource(_a0 *secretsmanager.TagResourceInput) (*secretsmanager.TagResourceOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.TagResourceOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.TagResourceInput) *secretsmanager.TagResourceOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.TagResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.TagResourceInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// TagResourceRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) TagResourceRequest(_a0 *secretsmanager.TagResourceInput) (*request.Request, *secretsmanager.TagResourceOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.TagResourceInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.TagResourceOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.TagResourceInput) *secretsmanager.TagResourceOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.TagResourceOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// TagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) TagResourceWithContext(_a0 context.Context, _a1 *secretsmanager.TagResourceInput, _a2 ...request.Option) (*secretsmanager.TagResourceOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.TagResourceOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.TagResourceInput, ...request.Option) *secretsmanager.TagResourceOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.TagResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.TagResourceInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UntagResource provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) UntagResource(_a0 *secretsmanager.UntagResourceInput) (*secretsmanager.UntagResourceOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.UntagResourceOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.UntagResourceInput) *secretsmanager.UntagResourceOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.UntagResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.UntagResourceInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UntagResourceRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) UntagResourceRequest(_a0 *secretsmanager.UntagResourceInput) (*request.Request, *secretsmanager.UntagResourceOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.UntagResourceInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.UntagResourceOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.UntagResourceInput) *secretsmanager.UntagResourceOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.UntagResourceOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UntagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) UntagResourceWithContext(_a0 context.Context, _a1 *secretsmanager.UntagResourceInput, _a2 ...request.Option) (*secretsmanager.UntagResourceOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.UntagResourceOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.UntagResourceInput, ...request.Option) *secretsmanager.UntagResourceOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.UntagResourceOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.UntagResourceInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateSecret provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) UpdateSecret(_a0 *secretsmanager.UpdateSecretInput) (*secretsmanager.UpdateSecretOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.UpdateSecretOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.UpdateSecretInput) *secretsmanager.UpdateSecretOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.UpdateSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.UpdateSecretInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateSecretRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) UpdateSecretRequest(_a0 *secretsmanager.UpdateSecretInput) (*request.Request, *secretsmanager.UpdateSecretOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.UpdateSecretInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.UpdateSecretOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.UpdateSecretInput) *secretsmanager.UpdateSecretOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.UpdateSecretOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateSecretVersionStage provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) UpdateSecretVersionStage(_a0 *secretsmanager.UpdateSecretVersionStageInput) (*secretsmanager.UpdateSecretVersionStageOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.UpdateSecretVersionStageOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.UpdateSecretVersionStageInput) *secretsmanager.UpdateSecretVersionStageOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.UpdateSecretVersionStageOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.UpdateSecretVersionStageInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateSecretVersionStageRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) UpdateSecretVersionStageRequest(_a0 *secretsmanager.UpdateSecretVersionStageInput) (*request.Request, *secretsmanager.UpdateSecretVersionStageOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.UpdateSecretVersionStageInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.UpdateSecretVersionStageOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.UpdateSecretVersionStageInput) *secretsmanager.UpdateSecretVersionStageOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.UpdateSecretVersionStageOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// UpdateSecretVersionStageWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) UpdateSecretVersionStageWithContext(_a0 context.Context, _a1 *secretsmanager.UpdateSecretVersionStageInput, _a2 ...request.Option) (*secretsmanager.UpdateSecretVersionStageOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.UpdateSecretVersionStageOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.UpdateSecretVersionStageInput, ...request.Option) *secretsmanager.UpdateSecretVersionStageOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.UpdateSecretVersionStageOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.UpdateSecretVersionStageInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// UpdateSecretWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) UpdateSecretWithContext(_a0 context.Context, _a1 *secretsmanager.UpdateSecretInput, _a2 ...request.Option) (*secretsmanager.UpdateSecretOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.UpdateSecretOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.UpdateSecretInput, ...request.Option) *secretsmanager.UpdateSecretOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.UpdateSecretOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.UpdateSecretInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ValidateResourcePolicy provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) ValidateResourcePolicy(_a0 *secretsmanager.ValidateResourcePolicyInput) (*secretsmanager.ValidateResourcePolicyOutput, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *secretsmanager.ValidateResourcePolicyOutput
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ValidateResourcePolicyInput) *secretsmanager.ValidateResourcePolicyOutput); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.ValidateResourcePolicyOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*secretsmanager.ValidateResourcePolicyInput) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ValidateResourcePolicyRequest provides a mock function with given fields: _a0
-func (_m *SecretsManagerAPI) ValidateResourcePolicyRequest(_a0 *secretsmanager.ValidateResourcePolicyInput) (*request.Request, *secretsmanager.ValidateResourcePolicyOutput) {
-	ret := _m.Called(_a0)
-
-	var r0 *request.Request
-	if rf, ok := ret.Get(0).(func(*secretsmanager.ValidateResourcePolicyInput) *request.Request); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*request.Request)
-		}
-	}
-
-	var r1 *secretsmanager.ValidateResourcePolicyOutput
-	if rf, ok := ret.Get(1).(func(*secretsmanager.ValidateResourcePolicyInput) *secretsmanager.ValidateResourcePolicyOutput); ok {
-		r1 = rf(_a0)
-	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*secretsmanager.ValidateResourcePolicyOutput)
-		}
-	}
-
-	return r0, r1
-}
-
-// ValidateResourcePolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
-func (_m *SecretsManagerAPI) ValidateResourcePolicyWithContext(_a0 context.Context, _a1 *secretsmanager.ValidateResourcePolicyInput, _a2 ...request.Option) (*secretsmanager.ValidateResourcePolicyOutput, error) {
-	_va := make([]interface{}, len(_a2))
-	for _i := range _a2 {
-		_va[_i] = _a2[_i]
-	}
-	var _ca []interface{}
-	_ca = append(_ca, _a0, _a1)
-	_ca = append(_ca, _va...)
-	ret := _m.Called(_ca...)
-
-	var r0 *secretsmanager.ValidateResourcePolicyOutput
-	if rf, ok := ret.Get(0).(func(context.Context, *secretsmanager.ValidateResourcePolicyInput, ...request.Option) *secretsmanager.ValidateResourcePolicyOutput); ok {
-		r0 = rf(_a0, _a1, _a2...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*secretsmanager.ValidateResourcePolicyOutput)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *secretsmanager.ValidateResourcePolicyInput, ...request.Option) error); ok {
-		r1 = rf(_a0, _a1, _a2...)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-type mockConstructorTestingTNewSecretsManagerAPI interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewSecretsManagerAPI creates a new instance of SecretsManagerAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewSecretsManagerAPI(t mockConstructorTestingTNewSecretsManagerAPI) *SecretsManagerAPI {
-	mock := &SecretsManagerAPI{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
+func (_c *SecretsManagerAPI_GetSecretValue_Call) RunAndReturn(run func(context1 context.Context, getSecretValueInput *secretsmanager.GetSecretValueInput, fns ...func(*secretsmanager.Options)) (*secretsmanager.GetSecretValueOutput, error)) *SecretsManagerAPI_GetSecretValue_Call {
+	_c.Call.Return(run)
+	return _c
 }
diff --git a/pkg/secrets/aws/secrets.go b/pkg/secrets/aws/secrets.go
index 3184376..fa99251 100644
--- a/pkg/secrets/aws/secrets.go
+++ b/pkg/secrets/aws/secrets.go
@@ -6,16 +6,14 @@ import (
 	"sort"
 	"strings"
 
-	"secrets-init/pkg/secrets" //nolint:gci
-
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/service/secretsmanager"
-	"github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface"
-	"github.com/aws/aws-sdk-go/service/ssm"
-	"github.com/aws/aws-sdk-go/service/ssm/ssmiface"
-	"github.com/pkg/errors" //nolint:gci
-
+	awssdk "github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
+	"github.com/aws/aws-sdk-go-v2/service/ssm"
+	"github.com/pkg/errors"
 	"github.com/tidwall/gjson"
+
+	"secrets-init/pkg/secrets"
 )
 
 const (
@@ -23,101 +21,146 @@ const (
 	paramNameTokensWithVersion = 7
 )
 
-// SecretsProvider AWS secrets provider
+// SecretsProvider AWS secrets provider.
 type SecretsProvider struct {
-	session *session.Session
-	sm      secretsmanageriface.SecretsManagerAPI
-	ssm     ssmiface.SSMAPI
+	sm  SecretsManagerAPI
+	ssm SSMAPI
 }
 
-// NewAwsSecretsProvider init AWS Secrets Provider
-func NewAwsSecretsProvider() (secrets.Provider, error) {
-	var err error
-	sp := SecretsProvider{}
-	// create AWS session
-	sp.session, err = session.NewSessionWithOptions(session.Options{SharedConfigState: session.SharedConfigEnable})
+// SecretsManagerAPI contains the Secrets Manager operation used by the provider.
+type SecretsManagerAPI interface {
+	GetSecretValue(context.Context, *secretsmanager.GetSecretValueInput, ...func(*secretsmanager.Options)) (*secretsmanager.GetSecretValueOutput, error)
+}
+
+// SSMAPI contains the Systems Manager operation used by the provider.
+type SSMAPI interface {
+	GetParameter(context.Context, *ssm.GetParameterInput, ...func(*ssm.Options)) (*ssm.GetParameterOutput, error)
+}
+
+// NewAwsSecretsProvider initializes the AWS secrets provider.
+func NewAwsSecretsProvider(ctx context.Context) (secrets.Provider, error) {
+	cfg, err := config.LoadDefaultConfig(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create AWS session")
+		return nil, errors.Wrap(err, "failed to load AWS configuration")
 	}
-	// init AWS Secrets Manager client
-	sp.sm = secretsmanager.New(sp.session)
-	// init AWS SSM client
-	sp.ssm = ssm.New(sp.session)
-	return &sp, nil
+
+	return &SecretsProvider{
+		sm:  secretsmanager.NewFromConfig(cfg),
+		ssm: ssm.NewFromConfig(cfg),
+	}, nil
 }
 
-// ResolveSecrets replaces all passed variables values prefixed with 'aws:aws:secretsmanager' and 'arn:aws:ssm:REGION:ACCOUNT:parameter'
-// by corresponding secrets from AWS Secret Manager and AWS Parameter Store
-func (sp *SecretsProvider) ResolveSecrets(_ context.Context, vars []string) ([]string, error) {
+// ResolveSecrets replaces AWS Secrets Manager and Parameter Store references with their values.
+func (sp *SecretsProvider) ResolveSecrets(ctx context.Context, vars []string) ([]string, error) {
 	envs := make([]string, 0, len(vars))
 
 	for _, env := range vars {
-		kv := strings.Split(env, "=")
-		key, value := kv[0], kv[1]
-		if strings.HasPrefix(value, "arn:aws:secretsmanager") || strings.HasPrefix(value, "arn:aws-cn:secretsmanager") {
-			secretKey, nestedKey, _ := strings.Cut(value, "$")
-
-			// get secret value
-			secret, err := sp.sm.GetSecretValue(&secretsmanager.GetSecretValueInput{SecretId: &secretKey})
-			if err != nil {
-				return vars, errors.Wrap(err, "failed to get secret from AWS Secrets Manager")
-			}
-
-			if IsJSON(secret.SecretString) {
-				if nestedKey != "" {
-					jsonValue := gjson.Get(*secret.SecretString, nestedKey)
-					if jsonValue.Exists() {
-						env = key + "=" + jsonValue.String()
-					}
-				} else {
-					var keyValueSecret map[string]string
-					err = json.Unmarshal([]byte(*secret.SecretString), &keyValueSecret)
-					if err != nil {
-						return vars, errors.Wrap(err, "failed to decode key/value secret")
-					}
-					for key, value := range keyValueSecret {
-						e := key + "=" + value
-						envs = append(envs, e)
-					}
-					continue // We continue to not add this ENV variable but only the environment variables that exists in the JSON
-				}
-			} else {
-				env = key + "=" + *secret.SecretString
-			}
-		} else if (strings.HasPrefix(value, "arn:aws:ssm") || strings.HasPrefix(value, "arn:aws-cn:ssm")) && strings.Contains(value, ":parameter/") {
-			tokens := strings.Split(value, ":")
-			// valid parameter ARN arn:aws:ssm:REGION:ACCOUNT:parameter/PATH
-			// or arn:aws:ssm:REGION:ACCOUNT:parameter/PATH:VERSION
-			if len(tokens) == paramNameTokens || len(tokens) == paramNameTokensWithVersion {
-				// get SSM parameter name (path)
-				paramName := strings.TrimPrefix(tokens[5], "parameter")
-
-				if len(tokens) == paramNameTokensWithVersion {
-					paramName = paramName + ":" + tokens[6]
-				}
-
-				// get AWS SSM API
-				withDecryption := true
-				param, err := sp.ssm.GetParameter(&ssm.GetParameterInput{
-					Name:           &paramName,
-					WithDecryption: &withDecryption,
-				})
-				if err != nil {
-					return vars, errors.Wrap(err, "failed to get secret from AWS Parameters Store")
-				}
-				env = key + "=" + *param.Parameter.Value
-			}
+		resolved, err := sp.resolveEnvironmentVariable(ctx, env)
+		if err != nil {
+			return vars, err
 		}
-		envs = append(envs, env)
+		envs = append(envs, resolved...)
 	}
+
 	sort.Strings(envs)
 	return envs, nil
 }
 
+func (sp *SecretsProvider) resolveEnvironmentVariable(ctx context.Context, env string) ([]string, error) {
+	key, value, found := strings.Cut(env, "=")
+	if !found {
+		return []string{env}, nil
+	}
+
+	switch {
+	case isSecretsManagerARN(value):
+		return sp.resolveSecretsManagerValue(ctx, env, key, value)
+	case isParameterStoreARN(value):
+		return sp.resolveParameterStoreValue(ctx, env, key, value)
+	default:
+		return []string{env}, nil
+	}
+}
+
+func (sp *SecretsProvider) resolveSecretsManagerValue(ctx context.Context, env, key, value string) ([]string, error) {
+	secretKey, nestedKey, _ := strings.Cut(value, "$")
+	secret, err := sp.sm.GetSecretValue(ctx, &secretsmanager.GetSecretValueInput{SecretId: awssdk.String(secretKey)})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get secret from AWS Secrets Manager")
+	}
+	if secret.SecretString == nil {
+		return nil, errors.New("AWS Secrets Manager secret does not contain a string value")
+	}
+
+	if !IsJSON(secret.SecretString) {
+		return []string{key + "=" + awssdk.ToString(secret.SecretString)}, nil
+	}
+	if nestedKey != "" {
+		jsonValue := gjson.Get(awssdk.ToString(secret.SecretString), nestedKey)
+		if !jsonValue.Exists() {
+			return []string{env}, nil
+		}
+		return []string{key + "=" + jsonValue.String()}, nil
+	}
+
+	var keyValueSecret map[string]string
+	if err = json.Unmarshal([]byte(awssdk.ToString(secret.SecretString)), &keyValueSecret); err != nil {
+		return nil, errors.Wrap(err, "failed to decode key/value secret")
+	}
+
+	resolved := make([]string, 0, len(keyValueSecret))
+	for secretKey, secretValue := range keyValueSecret {
+		resolved = append(resolved, secretKey+"="+secretValue)
+	}
+	return resolved, nil
+}
+
+func (sp *SecretsProvider) resolveParameterStoreValue(ctx context.Context, env, key, value string) ([]string, error) {
+	paramName, valid := parameterName(value)
+	if !valid {
+		return []string{env}, nil
+	}
+
+	param, err := sp.ssm.GetParameter(ctx, &ssm.GetParameterInput{
+		Name:           awssdk.String(paramName),
+		WithDecryption: awssdk.Bool(true),
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get secret from AWS Parameters Store")
+	}
+	if param.Parameter == nil || param.Parameter.Value == nil {
+		return nil, errors.New("AWS Parameter Store parameter does not contain a value")
+	}
+
+	return []string{key + "=" + awssdk.ToString(param.Parameter.Value)}, nil
+}
+
+func isSecretsManagerARN(value string) bool {
+	return strings.HasPrefix(value, "arn:aws:secretsmanager") || strings.HasPrefix(value, "arn:aws-cn:secretsmanager")
+}
+
+func isParameterStoreARN(value string) bool {
+	return (strings.HasPrefix(value, "arn:aws:ssm") || strings.HasPrefix(value, "arn:aws-cn:ssm")) &&
+		strings.Contains(value, ":parameter/")
+}
+
+func parameterName(value string) (string, bool) {
+	tokens := strings.Split(value, ":")
+	if len(tokens) != paramNameTokens && len(tokens) != paramNameTokensWithVersion {
+		return "", false
+	}
+
+	name := strings.TrimPrefix(tokens[5], "parameter")
+	if len(tokens) == paramNameTokensWithVersion {
+		name += ":" + tokens[6]
+	}
+	return name, true
+}
+
+// IsJSON reports whether str contains valid JSON.
 func IsJSON(str *string) bool {
 	if str == nil {
 		return false
 	}
-	var js json.RawMessage
-	return json.Unmarshal([]byte(*str), &js) == nil
+	return json.Valid([]byte(*str))
 }
diff --git a/pkg/secrets/aws/secrets_test.go b/pkg/secrets/aws/secrets_test.go
index b452d0f..84b6099 100644
--- a/pkg/secrets/aws/secrets_test.go
+++ b/pkg/secrets/aws/secrets_test.go
@@ -7,11 +7,13 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
+	"github.com/aws/aws-sdk-go-v2/service/ssm"
+	"github.com/aws/aws-sdk-go-v2/service/ssm/types"
+	"github.com/stretchr/testify/mock"
+
 	"secrets-init/mocks"
 	"secrets-init/pkg/secrets"
-
-	"github.com/aws/aws-sdk-go/service/secretsmanager"
-	"github.com/aws/aws-sdk-go/service/ssm"
 )
 
 func TestSecretsProvider_ResolveSecrets(t *testing.T) {
@@ -36,7 +38,7 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 				secretValue := "test-secret-value"
 				valueInput := secretsmanager.GetSecretValueInput{SecretId: &secretName}
 				valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &secretValue}
-				mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+				mockSM.On("GetSecretValue", mock.Anything, &valueInput).Return(&valueOutput, nil)
 				return &sp
 			},
 		},
@@ -63,7 +65,7 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 					value := v
 					valueInput := secretsmanager.GetSecretValueInput{SecretId: &name}
 					valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &value}
-					mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+					mockSM.On("GetSecretValue", mock.Anything, &valueInput).Return(&valueOutput, nil)
 				}
 				return &sp
 			},
@@ -87,7 +89,7 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 					value := v
 					valueInput := secretsmanager.GetSecretValueInput{SecretId: &name}
 					valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &value}
-					mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+					mockSM.On("GetSecretValue", mock.Anything, &valueInput).Return(&valueOutput, nil)
 				}
 				return &sp
 			},
@@ -114,7 +116,7 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 					value := v
 					valueInput := secretsmanager.GetSecretValueInput{SecretId: &name}
 					valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &value}
-					mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+					mockSM.On("GetSecretValue", mock.Anything, &valueInput).Return(&valueOutput, nil)
 				}
 				return &sp
 			},
@@ -143,7 +145,7 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 					value := v
 					valueInput := secretsmanager.GetSecretValueInput{SecretId: &name}
 					valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &value}
-					mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+					mockSM.On("GetSecretValue", mock.Anything, &valueInput).Return(&valueOutput, nil)
 				}
 				return &sp
 			},
@@ -151,10 +153,12 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 		{
 			name: "no secrets",
 			vars: []string{
+				"encoded=value=with=separators",
 				"non-secret-1=hello-1",
 				"non-secret-2=hello-2",
 			},
 			want: []string{
+				"encoded=value=with=separators",
 				"non-secret-1=hello-1",
 				"non-secret-2=hello-2",
 			},
@@ -177,7 +181,24 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 				sp := SecretsProvider{sm: mockSM, ssm: mockSSM}
 				secretName := "arn:aws:secretsmanager:12345678"
 				valueInput := secretsmanager.GetSecretValueInput{SecretId: &secretName}
-				mockSM.On("GetSecretValue", &valueInput).Return(nil, errors.New("test error"))
+				mockSM.On("GetSecretValue", mock.Anything, &valueInput).Return(nil, errors.New("test error"))
+				return &sp
+			},
+		},
+		{
+			name: "error getting non-string secret from Secrets Manager",
+			vars: []string{
+				"test-secret=arn:aws:secretsmanager:12345678",
+			},
+			want: []string{
+				"test-secret=arn:aws:secretsmanager:12345678",
+			},
+			wantErr: true,
+			mockServiceProvider: func(mockSM *mocks.SecretsManagerAPI, mockSSM *mocks.SSMAPI) secrets.Provider {
+				sp := SecretsProvider{sm: mockSM, ssm: mockSSM}
+				secretName := "arn:aws:secretsmanager:12345678"
+				valueInput := secretsmanager.GetSecretValueInput{SecretId: &secretName}
+				mockSM.On("GetSecretValue", mock.Anything, &valueInput).Return(&secretsmanager.GetSecretValueOutput{}, nil)
 				return &sp
 			},
 		},
@@ -195,8 +216,8 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 				secretValue := "test-secret-value"
 				withDecryption := true
 				valueInput := ssm.GetParameterInput{Name: &secretName, WithDecryption: &withDecryption}
-				valueOutput := ssm.GetParameterOutput{Parameter: &ssm.Parameter{Value: &secretValue}}
-				mockSSM.On("GetParameter", &valueInput).Return(&valueOutput, nil)
+				valueOutput := ssm.GetParameterOutput{Parameter: &types.Parameter{Value: &secretValue}}
+				mockSSM.On("GetParameter", mock.Anything, &valueInput).Return(&valueOutput, nil)
 				return &sp
 			},
 		},
@@ -216,7 +237,25 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 				secretName := "/secrets/test-secret"
 				withDecryption := true
 				valueInput := ssm.GetParameterInput{Name: &secretName, WithDecryption: &withDecryption}
-				mockSSM.On("GetParameter", &valueInput).Return(nil, errors.New("test error"))
+				mockSSM.On("GetParameter", mock.Anything, &valueInput).Return(nil, errors.New("test error"))
+				return &sp
+			},
+		},
+		{
+			name: "error getting empty value from SSM Parameter Store",
+			vars: []string{
+				"test-secret=arn:aws:ssm:us-east-1:12345678:parameter/secrets/test-secret",
+			},
+			want: []string{
+				"test-secret=arn:aws:ssm:us-east-1:12345678:parameter/secrets/test-secret",
+			},
+			wantErr: true,
+			mockServiceProvider: func(mockSM *mocks.SecretsManagerAPI, mockSSM *mocks.SSMAPI) secrets.Provider {
+				sp := SecretsProvider{sm: mockSM, ssm: mockSSM}
+				secretName := "/secrets/test-secret"
+				withDecryption := true
+				valueInput := ssm.GetParameterInput{Name: &secretName, WithDecryption: &withDecryption}
+				mockSSM.On("GetParameter", mock.Anything, &valueInput).Return(&ssm.GetParameterOutput{}, nil)
 				return &sp
 			},
 		},
@@ -234,7 +273,7 @@ func TestSecretsProvider_ResolveSecrets(t *testing.T) {
 				secretValue := "{\"level$key\": \"the-value-for-level$key\"}"
 				valueInput := secretsmanager.GetSecretValueInput{SecretId: &secretName}
 				valueOutput := secretsmanager.GetSecretValueOutput{SecretString: &secretValue}
-				mockSM.On("GetSecretValue", &valueInput).Return(&valueOutput, nil)
+				mockSM.On("GetSecretValue", mock.Anything, &valueInput).Return(&valueOutput, nil)
 				return &sp
 			},
 		},
diff --git a/pkg/secrets/google/interface.go b/pkg/secrets/google/interface.go
index 97d9a5b..e2b3bd3 100644
--- a/pkg/secrets/google/interface.go
+++ b/pkg/secrets/google/interface.go
@@ -3,8 +3,8 @@ package google
 import (
 	"context"
 
+	secretspb "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb"
 	gax "github.com/googleapis/gax-go/v2"
-	secretspb "google.golang.org/genproto/googleapis/cloud/secretmanager/v1"
 )
 
 // SecretsManagerAPI is the interface for the Google Secrets Manager API.
diff --git a/pkg/secrets/google/secrets.go b/pkg/secrets/google/secrets.go
index 8dec6e1..6b35343 100644
--- a/pkg/secrets/google/secrets.go
+++ b/pkg/secrets/google/secrets.go
@@ -7,13 +7,13 @@ import (
 	"strings"
 	"sync"
 
-	"secrets-init/pkg/secrets" //nolint:gci
-
 	"cloud.google.com/go/compute/metadata"
 	secretmanager "cloud.google.com/go/secretmanager/apiv1"
+	secretspb "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
-	secretspb "google.golang.org/genproto/googleapis/cloud/secretmanager/v1" //nolint:gci
+
+	"secrets-init/pkg/secrets"
 )
 
 var fullSecretRe = regexp.MustCompile(`projects/[^/]+/secrets/[^/+](/version/[^/+])?`)
@@ -37,7 +37,7 @@ func NewGoogleSecretsProvider(ctx context.Context, projectID string) (secrets.Pr
 	if projectID != "" {
 		sp.projectID = projectID
 	} else {
-		sp.projectID, err = metadata.ProjectID()
+		sp.projectID, err = metadata.ProjectIDWithContext(ctx)
 		if err != nil {
 			log.WithError(err).Infoln("The Google project cannot be detected, you won't be able to use the short secret version")
 		}
diff --git a/pkg/secrets/google/secrets_test.go b/pkg/secrets/google/secrets_test.go
index b42d754..4684a56 100644
--- a/pkg/secrets/google/secrets_test.go
+++ b/pkg/secrets/google/secrets_test.go
@@ -6,11 +6,11 @@ import (
 	"errors"
 	"testing"
 
+	secretspb "cloud.google.com/go/secretmanager/apiv1/secretmanagerpb"
+	"github.com/stretchr/testify/assert"
+
 	"secrets-init/mocks"
 	"secrets-init/pkg/secrets"
-
-	"github.com/stretchr/testify/assert"
-	secretspb "google.golang.org/genproto/googleapis/cloud/secretmanager/v1"
 )
 
 func TestSecretsProvider_ResolveSecrets(t *testing.T) {

From 4600faac9d8f5d007befa916e0e90f040b1931f1 Mon Sep 17 00:00:00 2001
From: ibrahimlawal <ibrahim@paystack.com>
Date: Fri, 17 Jul 2026 16:35:44 +0100
Subject: [PATCH 11/12] PSR-41: run CI for nested refs

---
 .github/workflows/test.yaml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index 63569a1..150453d 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -3,15 +3,15 @@ name: test
 on:
   push:
     branches:
-      - '*'
+      - '**'
     tags:
-      - '*'
+      - '**'
     paths-ignore:
       - 'docs/**'
       - '*.md'
   pull_request:
     branches:
-      - '*'
+      - '**'
 env:
   GOPROXY: https://proxy.golang.org
   CGO_ENABLED: 0

From 2601da27294bde002a34510d643271f7f84ca50b Mon Sep 17 00:00:00 2001
From: ibrahimlawal-paystack <ibrahim@paystack.com>
Date: Mon, 20 Jul 2026 17:16:02 +0100
Subject: [PATCH 12/12] Harden build and release pipeline

---
 .dockerignore                         |  5 +-
 .github/workflows/docker-release.yaml | 70 ++++++++++++++++++++-------
 .github/workflows/github-release.yaml | 48 +++++++++++++++---
 .github/workflows/test.yaml           | 22 +++++----
 Dockerfile                            | 37 +++++++-------
 Makefile                              | 52 ++++++++++++++------
 README.md                             |  8 +++
 go.mod                                | 12 ++---
 go.sum                                | 24 ++++-----
 main.go                               | 12 ++---
 main_test.go                          | 68 ++++++++++++++++++++++++++
 scripts/build.sh                      | 30 ++++++++++++
 scripts/write-checksums.sh            | 25 ++++++++++
 13 files changed, 315 insertions(+), 98 deletions(-)
 create mode 100644 main_test.go
 create mode 100755 scripts/build.sh
 create mode 100755 scripts/write-checksums.sh

diff --git a/.dockerignore b/.dockerignore
index 694e91e..1d86adb 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,6 +1,9 @@
 # binaries
 .bin
 
+# version control
+.git
+
 # coverage
 .cover
 
@@ -20,7 +23,7 @@
 docs
 
 # customization and secrets
-.env
+.env*
 
 # license
 LICENSE
diff --git a/.github/workflows/docker-release.yaml b/.github/workflows/docker-release.yaml
index 0bde54e..608433f 100644
--- a/.github/workflows/docker-release.yaml
+++ b/.github/workflows/docker-release.yaml
@@ -1,7 +1,6 @@
 name: docker
 
 on:
-  workflow_dispatch:
   push:
     tags:
       - '[0-9]+.[0-9]+.[0-9]+'
@@ -13,59 +12,92 @@ permissions:
   contents: read
   packages: write
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
 jobs:
   release:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
+        with:
+          persist-credentials: false
+
+      - name: Install Go
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6
+        with:
+          go-version: '1.26.5'
+          cache: true
+
+      - name: Verify source
+        run: make verify
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
+        uses: docker/setup-qemu-action@96fe6ef7f33517b61c61be40b68a1882f3264fb8 # v4
 
       - name: Set up Docker buildx
         id: buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4
 
       - name: Login to Docker Registry
-        uses: docker/login-action@v4
+        uses: docker/login-action@af1e73f918a031802d376d3c8bbc3fe56130a9b0 # v4
         with:
           registry: ${{ secrets.DOCKER_REGISTRY }}
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@v4
+        uses: docker/login-action@af1e73f918a031802d376d3c8bbc3fe56130a9b0 # v4
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
-          password: ${{ secrets.CR_PAT }}
+          password: ${{ github.token }}
 
       - name: Available platforms
-        run: echo "${{ steps.buildx.outputs.platforms }}"
+        env:
+          AVAILABLE_PLATFORMS: ${{ steps.buildx.outputs.platforms }}
+        run: printf '%s\n' "$AVAILABLE_PLATFORMS"
 
       - name: Decide on image name
         id: nomenclator
         env:
           DOCKER_REPOSITORY: ${{ secrets.DOCKER_REPOSITORY }}
         run: |
+          set -euo pipefail
           name="${DOCKER_REPOSITORY:-${GITHUB_REPOSITORY}}"
-          echo "name=${name}" >> "$GITHUB_OUTPUT"
-          echo "::debug::docker image name ${name}"
+          printf 'name=%s\n' "$name" >> "$GITHUB_OUTPUT"
 
-      - name: Decide on tag
+      - name: Validate release tag
         id: tagger
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
         run: |
-          tag=$(echo "${GITHUB_REF}" | sed -e 's/^refs\/heads\///g' -e 's/^refs\/tags\///g' -e 's/^refs\/pull\///g' -e 's/\/merge$//g' | sed -e 's/master/latest/g')
-          echo "tag=${tag}" >> "$GITHUB_OUTPUT"
-          echo "::debug::docker image tag ${tag}"
+          set -euo pipefail
+          if [[ ! "$RELEASE_TAG" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            printf 'invalid release tag: %s\n' "$RELEASE_TAG" >&2
+            exit 1
+          fi
+          printf 'tag=%s\n' "$RELEASE_TAG" >> "$GITHUB_OUTPUT"
+
+      - name: Read source date
+        id: source
+        env:
+          SOURCE_COMMIT: ${{ github.sha }}
+        run: printf 'date=%s\n' "$(git show -s --format=%cI "$SOURCE_COMMIT")" >> "$GITHUB_OUTPUT"
 
       - name: Build and push Docker image
         id: build-push
-        uses: docker/build-push-action@v7
+        uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7
         with:
-          build-args: VERSION=${{ steps.tagger.outputs.tag }}
+          build-args: |
+            VERSION=${{ steps.tagger.outputs.tag }}
+            BUILD_DATE=${{ steps.source.outputs.date }}
+            COMMIT=${{ github.sha }}
+            BRANCH=${{ github.ref_name }}
           platforms: linux/amd64,linux/arm64
           tags: |
             ${{ steps.nomenclator.outputs.name }}:${{ steps.tagger.outputs.tag }}
@@ -75,4 +107,6 @@ jobs:
           push: true
 
       - name: Image digest
-        run: echo "${{ steps.build-push.outputs.digest }}"
+        env:
+          IMAGE_DIGEST: ${{ steps.build-push.outputs.digest }}
+        run: printf '%s\n' "$IMAGE_DIGEST"
diff --git a/.github/workflows/github-release.yaml b/.github/workflows/github-release.yaml
index b996453..f20f558 100644
--- a/.github/workflows/github-release.yaml
+++ b/.github/workflows/github-release.yaml
@@ -1,7 +1,6 @@
 name: github
 
 on:
-  workflow_dispatch:
   push:
     tags:
       - '[0-9]+.[0-9]+.[0-9]+'
@@ -12,33 +11,66 @@ on:
 permissions:
   contents: write
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
 jobs:
   release:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
+        with:
+          persist-credentials: false
 
       - name: Install Go
-        uses: actions/setup-go@v7
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6
         with:
           go-version: '1.26.5'
           cache: true
 
-      - name: Cross-Platform build
+      - name: Validate release tag
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
         run: |
-          make platform-build
+          set -euo pipefail
+          if [[ ! "$RELEASE_TAG" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            printf 'invalid release tag: %s\n' "$RELEASE_TAG" >&2
+            exit 1
+          fi
+
+      - name: Read source date
+        id: source
+        env:
+          SOURCE_COMMIT: ${{ github.sha }}
+        run: printf 'date=%s\n' "$(git show -s --format=%cI "$SOURCE_COMMIT")" >> "$GITHUB_OUTPUT"
+
+      - name: Cross-platform build
+        env:
+          BRANCH: ${{ github.ref_name }}
+          COMMIT: ${{ github.sha }}
+          DATE: ${{ steps.source.outputs.date }}
+          VERSION: ${{ github.ref_name }}
+        run: make platform-build
+
+      - name: Generate checksums
+        run: ./scripts/write-checksums.sh .bin
 
       - name: Build Changelog
         id: build_changelog
-        uses: mikepenz/release-changelog-builder-action@v6
+        uses: mikepenz/release-changelog-builder-action@c9bcd8238b6f41e05561348339429d360b1c0247 # v6
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Create Release
-        uses: softprops/action-gh-release@v3
+        uses: softprops/action-gh-release@3d0d9888cb7fd7b750713d6e236d1fcb99157228 # v3
         with:
           body: ${{ steps.build_changelog.outputs.changelog }}
+          fail_on_unmatched_files: true
           files: |
             .bin/*
+          overwrite_files: false
+          tag_name: ${{ github.ref_name }}
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index 150453d..25c0aca 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -21,22 +21,26 @@ permissions:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
+        with:
+          persist-credentials: false
 
       - name: Install Go
-        uses: actions/setup-go@v7
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6
         with:
           go-version: '1.26.5'
           cache: true
 
-      - name: Lint
-        run: |
-          make lint
+      - name: Build release artifacts
+        run: make platform-build
+
+      - name: Generate release checksums
+        run: ./scripts/write-checksums.sh .bin
 
-      - name: Test
-        run: |
-          make test
+      - name: Race test
+        run: make CGO_ENABLED=1 test-race
diff --git a/Dockerfile b/Dockerfile
index bda2506..0db611e 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,32 +1,29 @@
-# syntax=docker/dockerfile:1
+# syntax=docker/dockerfile:1@sha256:87999aa3d42bdc6bea60565083ee17e86d1f3339802f543c0d03998580f9cb89
 
-FROM --platform=${BUILDPLATFORM} golang:1.26.5-alpine AS builder
-# passed by buildkit
+FROM --platform=${BUILDPLATFORM} golang:1.26.5-alpine@sha256:0178a641fbb4858c5f1b48e34bdaabe0350a330a1b1149aabd498d0699ff5fb2 AS builder
 ARG TARGETOS
 ARG TARGETARCH
 ARG VERSION=v0
-# add CA certificates and TZ for local time
-RUN apk add --no-cache ca-certificates make git
-# Create and change to the app directory.
-RUN mkdir -p /go/src/app
+ARG BUILD_DATE=unknown
+ARG COMMIT=unknown
+ARG BRANCH=unknown
+
 WORKDIR /go/src/app
-# Retrieve application dependencies.
-# This allows the container build to reuse cached dependencies.
-# Expecting to copy go.mod and if present go.sum.
+
 COPY go.mod go.sum ./
-RUN --mount=type=cache,target=/go/pkg/mod go mod download
-# Copy local code to the container image.
+RUN --mount=type=cache,target=/go/pkg/mod \
+    go mod download && go mod verify
+
 COPY . .
-# Build the binary.
-RUN --mount=type=cache,target=/root/.cache/go-build \
-    TARGETOS=${TARGETOS} TARGETARCH=${TARGETARCH} make VERSION=${VERSION}
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    GO=go TARGETOS=${TARGETOS} TARGETARCH=${TARGETARCH} \
+    VERSION=${VERSION} DATE=${BUILD_DATE} COMMIT=${COMMIT} BRANCH=${BRANCH} \
+    OUTPUT=/out/secrets-init ./scripts/build.sh
 
-# final image
-FROM busybox:1.38.0
-# copy certificates
+FROM busybox:1.38.0@sha256:fd8d9aa63ba2f0982b5304e1ee8d3b90a210bc1ffb5314d980eb6962f1a9715d
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
-# copy the binary to the production image from the builder stage.
-COPY --from=builder /go/src/app/.bin/secrets-init /secrets-init
+COPY --from=builder /out/secrets-init /secrets-init
 RUN adduser -D -u 1000 secrets-init
 USER 1000
 
diff --git a/Makefile b/Makefile
index d74972c..dacd312 100644
--- a/Makefile
+++ b/Makefile
@@ -14,7 +14,7 @@ PLATFORMS     = darwin linux
 ARCHITECTURES = amd64 arm64
 TARGETOS   ?= $(GOOS)
 TARGETARCH ?= $(GOARCH)
-LDFLAGS_VERSION = -s -w -X main.Version=$(VERSION) -X main.BuildDate=$(DATE) -X main.GitCommit=$(COMMIT) -X main.GitBranch=$(BRANCH)
+BUILD_SCRIPT = $(CURDIR)/scripts/build.sh
 
 DOCKER  = docker
 GO      = go
@@ -28,24 +28,21 @@ export CGO_ENABLED=0
 export GOPROXY=https://proxy.golang.org
 
 .PHONY: all
-all: fmt lint test ; $(info $(M) building executable...) @ ## Build program binary
-	$Q env GOOS=$(TARGETOS) GOARCH=$(TARGETARCH) $(GO) build \
-		-tags release \
-		-ldflags "$(LDFLAGS_VERSION) -X main.Platform=$(TARGETOS)/$(TARGETARCH)" \
-		-o $(BIN)/$(basename $(MODULE)) main.go
+all: verify ; $(info $(M) building executable...) @ ## Build program binary
+	$Q env GO="$(GO)" TARGETOS="$(TARGETOS)" TARGETARCH="$(TARGETARCH)" \
+		VERSION="$(VERSION)" DATE="$(DATE)" COMMIT="$(COMMIT)" BRANCH="$(BRANCH)" \
+		OUTPUT="$(BIN)/$(basename $(MODULE))" $(BUILD_SCRIPT)
 
 # Release for multiple platforms
 
 .PHONY: platform-build platfrom-build
-platform-build: clean lint test ; $(info $(M) building binaries for multiple os/arch...) @ ## Build program binary for platforms and os
+platform-build: clean verify ; $(info $(M) building binaries for multiple os/arch...) @ ## Build program binary for platforms and os
 	$Q set -eu; \
 	for target_os in $(PLATFORMS); do \
 		for target_arch in $(ARCHITECTURES); do \
-			GOPROXY=$(GOPROXY) CGO_ENABLED=$(CGO_ENABLED) GOOS=$$target_os GOARCH=$$target_arch \
-				$(GO) build \
-				-tags release \
-				-ldflags "$(LDFLAGS_VERSION) -X main.Platform=$$target_os/$$target_arch" \
-				-o $(BIN)/$(basename $(MODULE))-$$target_os-$$target_arch main.go; \
+			env GO="$(GO)" TARGETOS="$$target_os" TARGETARCH="$$target_arch" \
+				VERSION="$(VERSION)" DATE="$(DATE)" COMMIT="$(COMMIT)" BRANCH="$(BRANCH)" \
+				OUTPUT="$(BIN)/$(basename $(MODULE))-$$target_os-$$target_arch" $(BUILD_SCRIPT); \
 		done; \
 	done
 
@@ -54,22 +51,28 @@ platfrom-build: platform-build
 
 # Tools
 
-setup-tools: setup-lint setup-gocov setup-gocov-xml setup-go2xunit setup-mockery setup-ghr
+setup-tools: setup-lint setup-vuln setup-actionlint setup-gocov setup-gocov-xml setup-go2xunit setup-mockery setup-ghr
 
 setup-lint:
 	$(GO) install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.12.2
+setup-vuln:
+	$(GO) install golang.org/x/vuln/cmd/govulncheck@v1.6.0
+setup-actionlint:
+	$(GO) install github.com/rhysd/actionlint/cmd/actionlint@v1.7.12
 setup-gocov:
-	$(GO) install github.com/axw/gocov/...
+	$(GO) install github.com/axw/gocov/...@v1.2.1
 setup-gocov-xml:
-	$(GO) install github.com/AlekSi/gocov-xml
+	$(GO) install github.com/AlekSi/gocov-xml@v1.2.0
 setup-go2xunit:
-	$(GO) install github.com/tebeka/go2xunit
+	$(GO) install github.com/tebeka/go2xunit@v1.4.10
 setup-mockery:
 	$(GO) install github.com/vektra/mockery/v3@v3.7.1
 setup-ghr:
 	$(GO) install github.com/tcnksm/ghr@v0.13.0
 
 GOLINT=golangci-lint
+GOVULNCHECK=govulncheck
+ACTIONLINT=actionlint
 GOCOV=gocov
 GOCOVXML=gocov-xml
 GO2XUNIT=go2xunit
@@ -113,8 +116,25 @@ test-coverage: fmt lint test-coverage-tools ; $(info $(M) running coverage tests
 
 .PHONY: lint
 lint: setup-lint ; $(info $(M) running golangci-lint) @ ## Run golangci-lint
+	$Q $(GOLINT) fmt --diff -c $(LINT_CONFIG)
 	$Q $(GOLINT) run --timeout=5m -v -c $(LINT_CONFIG) ./...
 
+.PHONY: modules-check
+modules-check: ; $(info $(M) verifying Go modules) @ ## Verify module files and downloaded dependencies
+	$Q $(GO) mod tidy -diff
+	$Q $(GO) mod verify
+
+.PHONY: vuln
+vuln: setup-vuln ; $(info $(M) scanning for reachable vulnerabilities) @ ## Scan source dependencies for known vulnerabilities
+	$Q $(GOVULNCHECK) ./...
+
+.PHONY: workflow-lint
+workflow-lint: setup-actionlint ; $(info $(M) validating GitHub Actions workflows) @ ## Validate workflow syntax and expressions
+	$Q $(ACTIONLINT) -no-color .github/workflows/*.yaml
+
+.PHONY: verify
+verify: modules-check lint workflow-lint vuln test ## Run all source verification checks
+
 .PHONY: fmt
 fmt: ; $(info $(M) running gofmt...) @ ## Run gofmt on all source files
 	$Q $(GO) fmt $(PKGS)
diff --git a/README.md b/README.md
index 3c7e39f..e38a226 100644
--- a/README.md
+++ b/README.md
@@ -149,3 +149,11 @@ The [kube-secrets-init](https://github.com/doitintl/kube-secrets-init) implement
 ## Code Reference
 
 Initial init system code was copied from [go-init](https://github.com/pablo-ruth/go-init) project.
+
+## Development
+
+- `make verify` checks module integrity, formatting, lint, workflow syntax, known reachable vulnerabilities, and tests.
+- `make platform-build` runs verification and builds all release binaries.
+- `./scripts/write-checksums.sh .bin` creates the release checksum manifest.
+
+Dependency updates use the newest compatible release that is at least six days old. An immediate security fix may use a newer release when no mature patched version exists. Release verification deliberately checks the current Go vulnerability database and fails closed when a reachable vulnerability is reported.
diff --git a/go.mod b/go.mod
index 906722a..fff83cd 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/aws/aws-sdk-go-v2 v1.42.1
 	github.com/aws/aws-sdk-go-v2/config v1.32.30
 	github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.43.1
-	github.com/aws/aws-sdk-go-v2/service/ssm v1.72.0
+	github.com/aws/aws-sdk-go-v2/service/ssm v1.71.1
 	github.com/googleapis/gax-go/v2 v2.23.0
 	github.com/pkg/errors v0.9.1
 	github.com/sirupsen/logrus v1.9.4
@@ -60,11 +60,11 @@ require (
 	golang.org/x/sync v0.22.0 // indirect
 	golang.org/x/text v0.40.0 // indirect
 	golang.org/x/time v0.15.0 // indirect
-	google.golang.org/api v0.289.0 // indirect
-	google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20260715232425-e75dac1f907d // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260715232425-e75dac1f907d // indirect
-	google.golang.org/grpc v1.82.1 // indirect
+	google.golang.org/api v0.288.0 // indirect
+	google.golang.org/genproto v0.0.0-20260630182238-925bb5da69e7 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7 // indirect
+	google.golang.org/grpc v1.82.0 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index 35c14b9..d0ce2a2 100644
--- a/go.sum
+++ b/go.sum
@@ -32,8 +32,8 @@ github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.43.1 h1:ZI18/nuaDBwwMJ95p
 github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.43.1/go.mod h1:oUyL28WfxY0RqPhFpkrWZx26Cu4JlyrWMMcWq8qqhi0=
 github.com/aws/aws-sdk-go-v2/service/signin v1.4.1 h1:V7ZZ300WPXGjvkyore5DGe0ljVPOxCXie/thWdtSBXE=
 github.com/aws/aws-sdk-go-v2/service/signin v1.4.1/go.mod h1:mxC0nT/C8wMMS97DemZPzvUZxvIt+2Iq+eS3JdFZGgg=
-github.com/aws/aws-sdk-go-v2/service/ssm v1.72.0 h1:jl+7QcR+PEJVQXK1W5NSXw9EKd+w7Cu4Pwj/WvUIHb0=
-github.com/aws/aws-sdk-go-v2/service/ssm v1.72.0/go.mod h1:xabzRvdbMs3FG9kU5M6RUOuCW6wXDkpdIqoXXNzA1nQ=
+github.com/aws/aws-sdk-go-v2/service/ssm v1.71.1 h1:hoteXNBbTKGz7ypkskBU6uS9BV2vwxkRcBy7kMIEGcU=
+github.com/aws/aws-sdk-go-v2/service/ssm v1.71.1/go.mod h1:xabzRvdbMs3FG9kU5M6RUOuCW6wXDkpdIqoXXNzA1nQ=
 github.com/aws/aws-sdk-go-v2/service/sso v1.32.1 h1:gYFYh4iLLcAOJRLNPY2aD2g9DIhKn4eof8UkIrr1rTk=
 github.com/aws/aws-sdk-go-v2/service/sso v1.32.1/go.mod h1:u8af9Nqkmqnr96f7v9nHqzZT9XBwbXEkTiqT4ROuJSE=
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.37.1 h1:arjT9Cm3/WYbGmD5TUZHk4UQn4Lle1fUNZs5FC6CtF0=
@@ -136,16 +136,16 @@ golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
 golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
 gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
 gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
-google.golang.org/api v0.289.0 h1:DmH0c6NigNFmsvsohM9bxv+MzVhag3aGHnojA5fFQjc=
-google.golang.org/api v0.289.0/go.mod h1:weJZ3lldHFYI0DBFNKpJelUDNnusTt5YaOEgxvt8ci8=
-google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d h1:C9v1o0/4quuhOAfmRXA2j+we0PqZIp8traLdeogF3Ms=
-google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU=
-google.golang.org/genproto/googleapis/api v0.0.0-20260715232425-e75dac1f907d h1:QwnJwPte4XXAkhPu26LTDIahnsMSUV0kK8HkxbC+Pc4=
-google.golang.org/genproto/googleapis/api v0.0.0-20260715232425-e75dac1f907d/go.mod h1:WRrQ7/7N19PypuT0fxLOL5Lq0waoiRri4FbtHDEKrGE=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260715232425-e75dac1f907d h1:Jkpk39hlTZOIp3RbfvNX9R8Hv+Sw0X89nlU/xFOErsc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260715232425-e75dac1f907d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
-google.golang.org/grpc v1.82.1 h1:NnAxzGRA0677vCa4BUkOAnO5+FfQqVl9iUXeD0IqcGE=
-google.golang.org/grpc v1.82.1/go.mod h1:yzTZ1TB1Z3SG+LIYaI+WiE8D5+PZ3ArnrSp8zF3+/ZA=
+google.golang.org/api v0.288.0 h1:glhO/J88obKP5I269W3hB73dvBKrjU56ZfmNlNXpgTU=
+google.golang.org/api v0.288.0/go.mod h1:lM2kYRzYUCBY91P9h6VF1PYmvhxii3O5hji37qRvIcY=
+google.golang.org/genproto v0.0.0-20260630182238-925bb5da69e7 h1:lQG76ePMKmtujel4VIVMiFoHVWVNtJdawbCZJtWlVXU=
+google.golang.org/genproto v0.0.0-20260630182238-925bb5da69e7/go.mod h1:LwlOWYBU335L+sR55UuR5fbbU8KmEX+3tUHf3SwMmhM=
+google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7 h1:jQ9p21COKWjP3VwuFrNRiiOTMh3mPpN45R7SLrH/HUU=
+google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7/go.mod h1:KqHwBx2upmfa1XSi1WuRvC+2VGCLtooKkfmyvRbUmqA=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7 h1:eM/YSd5bBFagF51o1E745Ta7RwzpW0h+z+QDNZOgmQ8=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
+google.golang.org/grpc v1.82.0 h1:vguDnZUPjE26w09A63VoxZPnvPjB5Riyc0mkXPFmAIU=
+google.golang.org/grpc v1.82.0/go.mod h1:yzTZ1TB1Z3SG+LIYaI+WiE8D5+PZ3ArnrSp8zF3+/ZA=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
 google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/main.go b/main.go
index 9d37e65..99149a2 100644
--- a/main.go
+++ b/main.go
@@ -39,7 +39,6 @@ const (
 	logFormatText = "text"
 	providerAWS   = "aws"
 	providerGCP   = "google"
-	logFieldArgs  = "args"
 )
 
 func main() {
@@ -258,9 +257,7 @@ func run(ctx context.Context, provider secrets.Provider, exitEarly, interactive
 
 	// start the specified command
 	log.WithFields(log.Fields{
-		"command":    commandStr,
-		logFieldArgs: argsSlice,
-		"env":        cmd.Env,
+		"command": commandStr,
 	}).Debug("starting command")
 	err = cmd.Start()
 	if err != nil {
@@ -281,10 +278,9 @@ func run(ctx context.Context, provider secrets.Provider, exitEarly, interactive
 				e := syscall.Kill(-cmd.Process.Pid, sig.(syscall.Signal))
 				if e != nil {
 					log.WithFields(log.Fields{
-						"pid":        cmd.Process.Pid,
-						"path":       cmd.Path,
-						logFieldArgs: cmd.Args,
-						"signal":     unix.SignalName(sig.(syscall.Signal)),
+						"pid":    cmd.Process.Pid,
+						"path":   cmd.Path,
+						"signal": unix.SignalName(sig.(syscall.Signal)),
 					}).WithError(e).Error("failed to send system signal to the process")
 				}
 			}
diff --git a/main_test.go b/main_test.go
new file mode 100644
index 0000000..1c6b796
--- /dev/null
+++ b/main_test.go
@@ -0,0 +1,68 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"strings"
+	"testing"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type staticProvider struct {
+	env []string
+}
+
+func (provider staticProvider) ResolveSecrets(context.Context, []string) ([]string, error) {
+	return provider.env, nil
+}
+
+func TestRunDoesNotLogArgumentsOrResolvedEnvironment(t *testing.T) {
+	const secret = "do-not-log-this-secret"
+
+	logger := log.StandardLogger()
+	originalOutput := logger.Out
+	originalLevel := logger.Level
+	originalFormatter := logger.Formatter
+	t.Cleanup(func() {
+		log.SetOutput(originalOutput)
+		log.SetLevel(originalLevel)
+		log.SetFormatter(originalFormatter)
+	})
+
+	var output bytes.Buffer
+	log.SetOutput(&output)
+	log.SetLevel(log.DebugLevel)
+	log.SetFormatter(&log.JSONFormatter{})
+
+	pid, err := run(
+		context.Background(),
+		staticProvider{env: []string{"API_TOKEN=" + secret}},
+		true,
+		false,
+		[]string{"true", "--token=" + secret},
+	)
+	if err != nil {
+		t.Fatalf("run() error = %v", err)
+	}
+
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		t.Fatalf("os.FindProcess() error = %v", err)
+	}
+	if _, err = process.Wait(); err != nil {
+		t.Fatalf("process.Wait() error = %v", err)
+	}
+
+	logs := output.String()
+	if strings.Contains(logs, secret) {
+		t.Fatalf("run() logged a secret: %s", logs)
+	}
+	if strings.Contains(logs, `"env"`) || strings.Contains(logs, `"args"`) {
+		t.Fatalf("run() logged sensitive fields: %s", logs)
+	}
+	if !strings.Contains(logs, `"command":"true"`) {
+		t.Fatalf("run() did not log the safe command field: %s", logs)
+	}
+}
diff --git a/scripts/build.sh b/scripts/build.sh
new file mode 100755
index 0000000..8091ea2
--- /dev/null
+++ b/scripts/build.sh
@@ -0,0 +1,30 @@
+#!/bin/sh
+
+set -eu
+
+go_bin=${GO:-go}
+target_os=${TARGETOS:-$("$go_bin" env GOOS)}
+target_arch=${TARGETARCH:-$("$go_bin" env GOARCH)}
+version=${VERSION:-v0}
+build_date=${DATE:-unknown}
+commit=${COMMIT:-unknown}
+branch=${BRANCH:-unknown}
+
+if [ -z "${OUTPUT:-}" ]; then
+	echo "OUTPUT is required" >&2
+	exit 1
+fi
+
+mkdir -p "$(dirname "$OUTPUT")"
+export CGO_ENABLED="${CGO_ENABLED:-0}"
+export GOOS="$target_os"
+export GOARCH="$target_arch"
+
+exec "$go_bin" build \
+	-mod=readonly \
+	-trimpath \
+	-buildvcs=false \
+	-tags release \
+	-ldflags "-s -w -X main.Version=$version -X main.BuildDate=$build_date -X main.GitCommit=$commit -X main.GitBranch=$branch -X main.Platform=$target_os/$target_arch" \
+	-o "$OUTPUT" \
+	main.go
diff --git a/scripts/write-checksums.sh b/scripts/write-checksums.sh
new file mode 100755
index 0000000..8f87cda
--- /dev/null
+++ b/scripts/write-checksums.sh
@@ -0,0 +1,25 @@
+#!/bin/sh
+
+set -eu
+
+artifact_dir=${1:-.bin}
+cd "$artifact_dir"
+
+set -- \
+	secrets-init-darwin-amd64 \
+	secrets-init-darwin-arm64 \
+	secrets-init-linux-amd64 \
+	secrets-init-linux-arm64
+
+for artifact do
+	if [ ! -s "$artifact" ]; then
+		echo "missing release artifact: $artifact" >&2
+		exit 1
+	fi
+done
+
+if command -v sha256sum >/dev/null 2>&1; then
+	sha256sum "$@" > SHA256SUMS
+else
+	shasum -a 256 "$@" > SHA256SUMS
+fi