diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..d9f56fc --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,34 @@ +name: release + +on: + push: + branches: + - "!**/*" + tags: + - "v*" + workflow_dispatch: + inputs: + tag: + description: "release tag" + required: true + type: string + +jobs: + goreleaser: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + with: + ref: ${{ inputs.tag || github.ref }} + - name: Set up Go + uses: actions/setup-go@v4 + with: + go-version: "1.21" + - name: Run GoReleaser + uses: goreleaser/goreleaser-action@v1 + with: + version: latest + args: release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/tagpr.yml b/.github/workflows/tagpr.yml new file mode 100644 index 0000000..dd426fe --- /dev/null +++ b/.github/workflows/tagpr.yml @@ -0,0 +1,12 @@ +name: tagpr +on: + push: + branches: ["main"] +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: Songmu/tagpr@main + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..ab72e5a --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,27 @@ +name: Go +on: [push, pull_request] +jobs: + test: + strategy: + matrix: + go: + - '1.20' + - '1.21' + name: Build + runs-on: ubuntu-latest + + steps: + - name: Set up Go + uses: actions/setup-go@v4 + with: + go-version: ${{ matrix.go }} + id: go + + - name: Check out code into the Go module directory + uses: actions/checkout@v3 + + - name: Build & Test + run: | + go test -race ./... + env: + GO111MODULE: on diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4fe81ae --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# Dependency directories (remove the comment below to include it) +# vendor/ + +.envrc diff --git a/.goreleaser.yml b/.goreleaser.yml new file mode 100644 index 0000000..160a4d4 --- /dev/null +++ b/.goreleaser.yml @@ -0,0 +1,25 @@ +before: + hooks: + - go mod download +builds: + - env: + - CGO_ENABLED=0 + main: cmd/aws-sdk-client-go/main.go + binary: aws-sdk-client-go + goos: + - linux + - darwin + - windows + goarch: + - amd64 + - arm64 +checksum: + name_template: "checksums.txt" +snapshot: + name_template: "{{ .Tag }}-next" +changelog: + sort: asc + filters: + exclude: + - "^docs:" + - "^test:" diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..b5530fc --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 FUJIWARA Shunichiro + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..03cbe50 --- /dev/null +++ b/Makefile @@ -0,0 +1,20 @@ +.PHONY: clean test + +aws-sdk-client-go: go.* *.go gen + go build -o $@ cmd/aws-sdk-client-go/main.go + +gen: + go run cmd/aws-sdk-client-gen/main.go + go fmt . + +clean: + rm -rf *_gen.go aws-sdk-client-go dist/ + +test: + go test -v ./... + +install: + go install github.com/fujiwara/aws-sdk-client-go/cmd/aws-sdk-client-go + +dist: + goreleaser build --snapshot --rm-dist diff --git a/README.md b/README.md new file mode 100644 index 0000000..2b9794b --- /dev/null +++ b/README.md @@ -0,0 +1,15 @@ +# {{ .Project.Name }} + +{{ .Project.Description }} + +## Usage + +aws-sdk-client-go + +## LICENSE + +{{ .Project.License }} + +## Author + +{{ .Project.Author.Name }} <{{ .Project.Author.Email }}> diff --git a/cmd/aws-sdk-client-gen/main.go b/cmd/aws-sdk-client-gen/main.go new file mode 100644 index 0000000..37b8774 --- /dev/null +++ b/cmd/aws-sdk-client-gen/main.go @@ -0,0 +1,89 @@ +package main + +import ( + "fmt" + "log" + "os" + "reflect" + "strings" + + "github.com/aws/aws-sdk-go-v2/service/ecs" + "github.com/aws/aws-sdk-go-v2/service/firehose" + "github.com/aws/aws-sdk-go-v2/service/kinesis" + "github.com/aws/aws-sdk-go-v2/service/ssm" +) + +func main() { + gen("kinesis", reflect.TypeOf(kinesis.New(kinesis.Options{}))) + gen("firehose", reflect.TypeOf(firehose.New(firehose.Options{}))) + gen("ssm", reflect.TypeOf(ssm.New(ssm.Options{}))) + gen("ecs", reflect.TypeOf(ecs.New(ecs.Options{}))) +} + +func gen(pkgName string, clientType reflect.Type) error { + buf := &strings.Builder{} + fmt.Fprintln(buf, "package sdkclient") + fmt.Fprintln(buf) + fmt.Fprintf(buf, `import ( + "context" + "encoding/json" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/%s" + ) + `, pkgName) + var methodNames []string + for i := 0; i < clientType.NumMethod(); i++ { + method := clientType.Method(i) + params := make([]string, 0) + for j := 0; j < method.Type.NumIn(); j++ { + params = append(params, method.Type.In(j).String()) + } + if len(params) <= 1 { + log.Printf("no params func %s", method.Name) + continue + } + methodNames = append(methodNames, method.Name) + + fmt.Fprintf(buf, `func %s_%s(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := %s.NewFromConfig(awsCfg) + var in %s + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %%w", err) + } + if out, err := svc.%s(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call %s: %%w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %%w", err) + } + return o, nil + } + } + `, + pkgName, + method.Name, + pkgName, + strings.TrimPrefix(params[2], "*"), // (receiver, context.Context, *Request, ...) + method.Name, + method.Name, + ) + fmt.Fprintln(buf) + } + fmt.Fprintln(buf, `func init() {`) + for _, name := range methodNames { + fmt.Fprintf(buf, `clientMethods["%s_%s"] = %s_%s + `, pkgName, name, pkgName, name) + } + fmt.Fprintln(buf, "}") + f, err := os.OpenFile(pkgName+"_gen.go", os.O_CREATE|os.O_WRONLY, 0644) + if err != nil { + return err + } + defer f.Close() + if _, err := f.WriteString(buf.String()); err != nil { + return err + } + log.Printf("generated %s_gen.go", pkgName) + return nil +} diff --git a/cmd/aws-sdk-client-go/main.go b/cmd/aws-sdk-client-go/main.go new file mode 100644 index 0000000..8ea10c2 --- /dev/null +++ b/cmd/aws-sdk-client-go/main.go @@ -0,0 +1,19 @@ +package main + +import ( + "context" + "log" + + app "github.com/fujiwara/aws-sdk-client-go" +) + +func main() { + ctx := context.TODO() + if err := run(ctx); err != nil { + log.Fatal(err) + } +} + +func run(ctx context.Context) error { + return app.Run(ctx) +} diff --git a/ecs_gen.go b/ecs_gen.go new file mode 100644 index 0000000..065319b --- /dev/null +++ b/ecs_gen.go @@ -0,0 +1,1019 @@ +package sdkclient + +import ( + "context" + "encoding/json" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/ecs" +) + +func ecs_CreateCapacityProvider(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.CreateCapacityProviderInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateCapacityProvider(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateCapacityProvider: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_CreateCluster(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.CreateClusterInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateCluster(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateCluster: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_CreateService(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.CreateServiceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateService(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateService: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_CreateTaskSet(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.CreateTaskSetInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateTaskSet(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateTaskSet: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeleteAccountSetting(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeleteAccountSettingInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteAccountSetting(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteAccountSetting: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeleteAttributes(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeleteAttributesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteAttributes(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteAttributes: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeleteCapacityProvider(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeleteCapacityProviderInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteCapacityProvider(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteCapacityProvider: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeleteCluster(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeleteClusterInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteCluster(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteCluster: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeleteService(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeleteServiceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteService(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteService: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeleteTaskDefinitions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeleteTaskDefinitionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteTaskDefinitions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteTaskDefinitions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeleteTaskSet(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeleteTaskSetInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteTaskSet(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteTaskSet: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeregisterContainerInstance(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeregisterContainerInstanceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeregisterContainerInstance(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeregisterContainerInstance: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DeregisterTaskDefinition(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DeregisterTaskDefinitionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeregisterTaskDefinition(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeregisterTaskDefinition: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DescribeCapacityProviders(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DescribeCapacityProvidersInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeCapacityProviders(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeCapacityProviders: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DescribeClusters(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DescribeClustersInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeClusters(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeClusters: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DescribeContainerInstances(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DescribeContainerInstancesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeContainerInstances(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeContainerInstances: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DescribeServices(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DescribeServicesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeServices(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeServices: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DescribeTaskDefinition(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DescribeTaskDefinitionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeTaskDefinition(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeTaskDefinition: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DescribeTaskSets(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DescribeTaskSetsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeTaskSets(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeTaskSets: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DescribeTasks(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DescribeTasksInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeTasks(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeTasks: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_DiscoverPollEndpoint(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.DiscoverPollEndpointInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DiscoverPollEndpoint(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DiscoverPollEndpoint: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ExecuteCommand(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ExecuteCommandInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ExecuteCommand(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ExecuteCommand: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_GetTaskProtection(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.GetTaskProtectionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetTaskProtection(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetTaskProtection: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListAccountSettings(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListAccountSettingsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListAccountSettings(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListAccountSettings: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListAttributes(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListAttributesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListAttributes(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListAttributes: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListClusters(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListClustersInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListClusters(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListClusters: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListContainerInstances(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListContainerInstancesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListContainerInstances(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListContainerInstances: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListServices(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListServicesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListServices(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListServices: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListServicesByNamespace(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListServicesByNamespaceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListServicesByNamespace(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListServicesByNamespace: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListTagsForResource(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListTagsForResourceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListTagsForResource(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListTagsForResource: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListTaskDefinitionFamilies(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListTaskDefinitionFamiliesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListTaskDefinitionFamilies(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListTaskDefinitionFamilies: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListTaskDefinitions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListTaskDefinitionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListTaskDefinitions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListTaskDefinitions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_ListTasks(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.ListTasksInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListTasks(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListTasks: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_PutAccountSetting(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.PutAccountSettingInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutAccountSetting(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutAccountSetting: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_PutAccountSettingDefault(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.PutAccountSettingDefaultInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutAccountSettingDefault(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutAccountSettingDefault: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_PutAttributes(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.PutAttributesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutAttributes(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutAttributes: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_PutClusterCapacityProviders(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.PutClusterCapacityProvidersInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutClusterCapacityProviders(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutClusterCapacityProviders: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_RegisterContainerInstance(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.RegisterContainerInstanceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RegisterContainerInstance(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RegisterContainerInstance: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_RegisterTaskDefinition(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.RegisterTaskDefinitionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RegisterTaskDefinition(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RegisterTaskDefinition: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_RunTask(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.RunTaskInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RunTask(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RunTask: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_StartTask(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.StartTaskInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StartTask(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StartTask: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_StopTask(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.StopTaskInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StopTask(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StopTask: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_SubmitAttachmentStateChanges(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.SubmitAttachmentStateChangesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.SubmitAttachmentStateChanges(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call SubmitAttachmentStateChanges: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_SubmitContainerStateChange(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.SubmitContainerStateChangeInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.SubmitContainerStateChange(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call SubmitContainerStateChange: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_SubmitTaskStateChange(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.SubmitTaskStateChangeInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.SubmitTaskStateChange(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call SubmitTaskStateChange: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_TagResource(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.TagResourceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.TagResource(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call TagResource: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UntagResource(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UntagResourceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UntagResource(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UntagResource: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateCapacityProvider(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateCapacityProviderInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateCapacityProvider(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateCapacityProvider: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateCluster(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateClusterInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateCluster(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateCluster: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateClusterSettings(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateClusterSettingsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateClusterSettings(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateClusterSettings: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateContainerAgent(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateContainerAgentInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateContainerAgent(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateContainerAgent: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateContainerInstancesState(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateContainerInstancesStateInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateContainerInstancesState(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateContainerInstancesState: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateService(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateServiceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateService(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateService: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateServicePrimaryTaskSet(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateServicePrimaryTaskSetInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateServicePrimaryTaskSet(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateServicePrimaryTaskSet: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateTaskProtection(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateTaskProtectionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateTaskProtection(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateTaskProtection: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ecs_UpdateTaskSet(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ecs.NewFromConfig(awsCfg) + var in ecs.UpdateTaskSetInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateTaskSet(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateTaskSet: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func init() { + clientMethods["ecs_CreateCapacityProvider"] = ecs_CreateCapacityProvider + clientMethods["ecs_CreateCluster"] = ecs_CreateCluster + clientMethods["ecs_CreateService"] = ecs_CreateService + clientMethods["ecs_CreateTaskSet"] = ecs_CreateTaskSet + clientMethods["ecs_DeleteAccountSetting"] = ecs_DeleteAccountSetting + clientMethods["ecs_DeleteAttributes"] = ecs_DeleteAttributes + clientMethods["ecs_DeleteCapacityProvider"] = ecs_DeleteCapacityProvider + clientMethods["ecs_DeleteCluster"] = ecs_DeleteCluster + clientMethods["ecs_DeleteService"] = ecs_DeleteService + clientMethods["ecs_DeleteTaskDefinitions"] = ecs_DeleteTaskDefinitions + clientMethods["ecs_DeleteTaskSet"] = ecs_DeleteTaskSet + clientMethods["ecs_DeregisterContainerInstance"] = ecs_DeregisterContainerInstance + clientMethods["ecs_DeregisterTaskDefinition"] = ecs_DeregisterTaskDefinition + clientMethods["ecs_DescribeCapacityProviders"] = ecs_DescribeCapacityProviders + clientMethods["ecs_DescribeClusters"] = ecs_DescribeClusters + clientMethods["ecs_DescribeContainerInstances"] = ecs_DescribeContainerInstances + clientMethods["ecs_DescribeServices"] = ecs_DescribeServices + clientMethods["ecs_DescribeTaskDefinition"] = ecs_DescribeTaskDefinition + clientMethods["ecs_DescribeTaskSets"] = ecs_DescribeTaskSets + clientMethods["ecs_DescribeTasks"] = ecs_DescribeTasks + clientMethods["ecs_DiscoverPollEndpoint"] = ecs_DiscoverPollEndpoint + clientMethods["ecs_ExecuteCommand"] = ecs_ExecuteCommand + clientMethods["ecs_GetTaskProtection"] = ecs_GetTaskProtection + clientMethods["ecs_ListAccountSettings"] = ecs_ListAccountSettings + clientMethods["ecs_ListAttributes"] = ecs_ListAttributes + clientMethods["ecs_ListClusters"] = ecs_ListClusters + clientMethods["ecs_ListContainerInstances"] = ecs_ListContainerInstances + clientMethods["ecs_ListServices"] = ecs_ListServices + clientMethods["ecs_ListServicesByNamespace"] = ecs_ListServicesByNamespace + clientMethods["ecs_ListTagsForResource"] = ecs_ListTagsForResource + clientMethods["ecs_ListTaskDefinitionFamilies"] = ecs_ListTaskDefinitionFamilies + clientMethods["ecs_ListTaskDefinitions"] = ecs_ListTaskDefinitions + clientMethods["ecs_ListTasks"] = ecs_ListTasks + clientMethods["ecs_PutAccountSetting"] = ecs_PutAccountSetting + clientMethods["ecs_PutAccountSettingDefault"] = ecs_PutAccountSettingDefault + clientMethods["ecs_PutAttributes"] = ecs_PutAttributes + clientMethods["ecs_PutClusterCapacityProviders"] = ecs_PutClusterCapacityProviders + clientMethods["ecs_RegisterContainerInstance"] = ecs_RegisterContainerInstance + clientMethods["ecs_RegisterTaskDefinition"] = ecs_RegisterTaskDefinition + clientMethods["ecs_RunTask"] = ecs_RunTask + clientMethods["ecs_StartTask"] = ecs_StartTask + clientMethods["ecs_StopTask"] = ecs_StopTask + clientMethods["ecs_SubmitAttachmentStateChanges"] = ecs_SubmitAttachmentStateChanges + clientMethods["ecs_SubmitContainerStateChange"] = ecs_SubmitContainerStateChange + clientMethods["ecs_SubmitTaskStateChange"] = ecs_SubmitTaskStateChange + clientMethods["ecs_TagResource"] = ecs_TagResource + clientMethods["ecs_UntagResource"] = ecs_UntagResource + clientMethods["ecs_UpdateCapacityProvider"] = ecs_UpdateCapacityProvider + clientMethods["ecs_UpdateCluster"] = ecs_UpdateCluster + clientMethods["ecs_UpdateClusterSettings"] = ecs_UpdateClusterSettings + clientMethods["ecs_UpdateContainerAgent"] = ecs_UpdateContainerAgent + clientMethods["ecs_UpdateContainerInstancesState"] = ecs_UpdateContainerInstancesState + clientMethods["ecs_UpdateService"] = ecs_UpdateService + clientMethods["ecs_UpdateServicePrimaryTaskSet"] = ecs_UpdateServicePrimaryTaskSet + clientMethods["ecs_UpdateTaskProtection"] = ecs_UpdateTaskProtection + clientMethods["ecs_UpdateTaskSet"] = ecs_UpdateTaskSet +} diff --git a/firehose_gen.go b/firehose_gen.go new file mode 100644 index 0000000..ad75da3 --- /dev/null +++ b/firehose_gen.go @@ -0,0 +1,227 @@ +package sdkclient + +import ( + "context" + "encoding/json" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/firehose" +) + +func firehose_CreateDeliveryStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.CreateDeliveryStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateDeliveryStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateDeliveryStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_DeleteDeliveryStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.DeleteDeliveryStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteDeliveryStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteDeliveryStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_DescribeDeliveryStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.DescribeDeliveryStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeDeliveryStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeDeliveryStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_ListDeliveryStreams(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.ListDeliveryStreamsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListDeliveryStreams(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListDeliveryStreams: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_ListTagsForDeliveryStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.ListTagsForDeliveryStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListTagsForDeliveryStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListTagsForDeliveryStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_PutRecord(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.PutRecordInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutRecord(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutRecord: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_PutRecordBatch(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.PutRecordBatchInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutRecordBatch(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutRecordBatch: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_StartDeliveryStreamEncryption(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.StartDeliveryStreamEncryptionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StartDeliveryStreamEncryption(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StartDeliveryStreamEncryption: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_StopDeliveryStreamEncryption(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.StopDeliveryStreamEncryptionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StopDeliveryStreamEncryption(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StopDeliveryStreamEncryption: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_TagDeliveryStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.TagDeliveryStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.TagDeliveryStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call TagDeliveryStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_UntagDeliveryStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.UntagDeliveryStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UntagDeliveryStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UntagDeliveryStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func firehose_UpdateDestination(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := firehose.NewFromConfig(awsCfg) + var in firehose.UpdateDestinationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateDestination(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateDestination: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func init() { + clientMethods["firehose_CreateDeliveryStream"] = firehose_CreateDeliveryStream + clientMethods["firehose_DeleteDeliveryStream"] = firehose_DeleteDeliveryStream + clientMethods["firehose_DescribeDeliveryStream"] = firehose_DescribeDeliveryStream + clientMethods["firehose_ListDeliveryStreams"] = firehose_ListDeliveryStreams + clientMethods["firehose_ListTagsForDeliveryStream"] = firehose_ListTagsForDeliveryStream + clientMethods["firehose_PutRecord"] = firehose_PutRecord + clientMethods["firehose_PutRecordBatch"] = firehose_PutRecordBatch + clientMethods["firehose_StartDeliveryStreamEncryption"] = firehose_StartDeliveryStreamEncryption + clientMethods["firehose_StopDeliveryStreamEncryption"] = firehose_StopDeliveryStreamEncryption + clientMethods["firehose_TagDeliveryStream"] = firehose_TagDeliveryStream + clientMethods["firehose_UntagDeliveryStream"] = firehose_UntagDeliveryStream + clientMethods["firehose_UpdateDestination"] = firehose_UpdateDestination +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..b2ad989 --- /dev/null +++ b/go.mod @@ -0,0 +1,32 @@ +module github.com/fujiwara/aws-sdk-client-go + +go 1.21.0 + +require ( + github.com/aws/aws-sdk-go-v2 v1.26.1 + github.com/aws/aws-sdk-go-v2/config v1.27.11 + github.com/aws/aws-sdk-go-v2/service/ecs v1.41.7 + github.com/aws/aws-sdk-go-v2/service/firehose v1.28.6 + github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.4 + github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1 + github.com/aws/aws-sdk-go-v2/service/ssm v1.50.0 +) + +require ( + github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.17.11 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.7 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 // indirect + github.com/aws/smithy-go v1.20.2 // indirect + github.com/jmespath/go-jmespath v0.4.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..f85b160 --- /dev/null +++ b/go.sum @@ -0,0 +1,52 @@ +github.com/aws/aws-sdk-go-v2 v1.26.1 h1:5554eUqIYVWpU0YmeeYZ0wU64H2VLBs8TlhRB2L+EkA= +github.com/aws/aws-sdk-go-v2 v1.26.1/go.mod h1:ffIFB97e2yNsv4aTSGkqtHnppsIJzw7G7BReUZ3jCXM= +github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 h1:x6xsQXGSmW6frevwDA+vi/wqhp1ct18mVXYN08/93to= +github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2/go.mod h1:lPprDr1e6cJdyYeGXnRaJoP4Md+cDBvi2eOj00BlGmg= +github.com/aws/aws-sdk-go-v2/config v1.27.11 h1:f47rANd2LQEYHda2ddSCKYId18/8BhSRM4BULGmfgNA= +github.com/aws/aws-sdk-go-v2/config v1.27.11/go.mod h1:SMsV78RIOYdve1vf36z8LmnszlRWkwMQtomCAI0/mIE= +github.com/aws/aws-sdk-go-v2/credentials v1.17.11 h1:YuIB1dJNf1Re822rriUOTxopaHHvIq0l/pX3fwO+Tzs= +github.com/aws/aws-sdk-go-v2/credentials v1.17.11/go.mod h1:AQtFPsDH9bI2O+71anW6EKL+NcD7LG3dpKGMV4SShgo= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 h1:FVJ0r5XTHSmIHJV6KuDmdYhEpvlHpiSd38RQWhut5J4= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1/go.mod h1:zusuAeqezXzAB24LGuzuekqMAEgWkVYukBec3kr3jUg= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 h1:aw39xVGeRWlWx9EzGVnhOR4yOjQDHPQ6o6NmBlscyQg= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5/go.mod h1:FSaRudD0dXiMPK2UjknVwwTYyZMRsHv3TtkabsZih5I= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 h1:PG1F3OD1szkuQPzDw3CIQsRIrtTlUC3lP84taWzHlq0= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5/go.mod h1:jU1li6RFryMz+so64PpKtudI+QzbKoIEivqdf6LNpOc= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5 h1:81KE7vaZzrl7yHBYHVEzYB8sypz11NMOZ40YlWvPxsU= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.5/go.mod h1:LIt2rg7Mcgn09Ygbdh/RdIm0rQ+3BNkbP1gyVMFtRK0= +github.com/aws/aws-sdk-go-v2/service/ecs v1.41.7 h1:aFdgmJ8G385PVC9mp8b9roGGHU/XbrKEQTbzl6V0GbE= +github.com/aws/aws-sdk-go-v2/service/ecs v1.41.7/go.mod h1:rcFIIrVk3NGCT3BV84HQM3ut+Dr1PO71UvvT8GeLAv4= +github.com/aws/aws-sdk-go-v2/service/firehose v1.28.6 h1:CRmkhpMI1lamkPYyg64imP7abIQlMFs+D916WFB3gFA= +github.com/aws/aws-sdk-go-v2/service/firehose v1.28.6/go.mod h1:78F+4pVJf6Qlg7a34oR2I2SpM/v0EUSAL/htTZ9trg4= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 h1:Ji0DY1xUsUr3I8cHps0G+XM3WWU16lP6yG8qu1GAZAs= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2/go.mod h1:5CsjAbs3NlGQyZNFACh+zztPDI7fU6eW9QsxjfnuBKg= +github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.7 h1:ZMeFZ5yk+Ek+jNr1+uwCd2tG89t6oTS5yVWpa6yy2es= +github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.7/go.mod h1:mxV05U+4JiHqIpGqqYXOHLPKUC6bDXC44bsUhNjOEwY= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7 h1:ogRAwT1/gxJBcSWDMZlgyFUM962F51A5CRhDLbxLdmo= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7/go.mod h1:YCsIZhXfRPLFFCl5xxY+1T9RKzOKjCut+28JSX2DnAk= +github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5 h1:f9RyWNtS8oH7cZlbn+/JNPpjUk5+5fLd5lM9M0i49Ys= +github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5/go.mod h1:h5CoMZV2VF297/VLhRhO1WF+XYWOzXo+4HsObA4HjBQ= +github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.4 h1:Oe8awBiS/iitcsRJB5+DHa3iCxoA0KwJJf0JNrYMINY= +github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.4/go.mod h1:RCZCSFbieSgNG1RKegO26opXV4EXyef/vNBVJsUyHuw= +github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1 h1:6cnno47Me9bRykw9AEv9zkXE+5or7jz8TsskTTccbgc= +github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1/go.mod h1:qmdkIIAC+GCLASF7R2whgNrJADz0QZPX+Seiw/i4S3o= +github.com/aws/aws-sdk-go-v2/service/ssm v1.50.0 h1:NGWDuvT6PAoWQuAYeqPU8UvKZjJ4CvxfgaCnT7E6sOI= +github.com/aws/aws-sdk-go-v2/service/ssm v1.50.0/go.mod h1:Ebk/HZmGhxWKDVxM4+pwbxGjm3RQOQLMjAEosI3ss9Q= +github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 h1:vN8hEbpRnL7+Hopy9dzmRle1xmDc7o8tmY0klsr175w= +github.com/aws/aws-sdk-go-v2/service/sso v1.20.5/go.mod h1:qGzynb/msuZIE8I75DVRCUXw3o3ZyBmUvMwQ2t/BrGM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 h1:Jux+gDDyi1Lruk+KHF91tK2KCuY61kzoCpvtvJJBtOE= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4/go.mod h1:mUYPBhaF2lGiukDEjJX2BLRRKTmoUSitGDUgM4tRxak= +github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 h1:cwIxeBttqPN3qkaAjcEcsh8NYr8n2HZPkcKgPAi1phU= +github.com/aws/aws-sdk-go-v2/service/sts v1.28.6/go.mod h1:FZf1/nKNEkHdGGJP/cI2MoIMquumuRK6ol3QQJNDxmw= +github.com/aws/smithy-go v1.20.2 h1:tbp628ireGtzcHDDmLT/6ADHidqnwgF57XOXZe6tp4Q= +github.com/aws/smithy-go v1.20.2/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +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/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/kinesis_gen.go b/kinesis_gen.go new file mode 100644 index 0000000..5f67e03 --- /dev/null +++ b/kinesis_gen.go @@ -0,0 +1,587 @@ +package sdkclient + +import ( + "context" + "encoding/json" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/kinesis" +) + +func kinesis_AddTagsToStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.AddTagsToStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.AddTagsToStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call AddTagsToStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_CreateStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.CreateStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DecreaseStreamRetentionPeriod(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DecreaseStreamRetentionPeriodInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DecreaseStreamRetentionPeriod(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DecreaseStreamRetentionPeriod: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DeleteResourcePolicy(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DeleteResourcePolicyInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteResourcePolicy(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteResourcePolicy: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DeleteStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DeleteStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DeregisterStreamConsumer(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DeregisterStreamConsumerInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeregisterStreamConsumer(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeregisterStreamConsumer: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DescribeLimits(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DescribeLimitsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeLimits(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeLimits: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DescribeStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DescribeStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DescribeStreamConsumer(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DescribeStreamConsumerInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeStreamConsumer(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeStreamConsumer: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DescribeStreamSummary(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DescribeStreamSummaryInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeStreamSummary(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeStreamSummary: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_DisableEnhancedMonitoring(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.DisableEnhancedMonitoringInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DisableEnhancedMonitoring(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DisableEnhancedMonitoring: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_EnableEnhancedMonitoring(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.EnableEnhancedMonitoringInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.EnableEnhancedMonitoring(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call EnableEnhancedMonitoring: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_GetRecords(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.GetRecordsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetRecords(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetRecords: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_GetResourcePolicy(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.GetResourcePolicyInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetResourcePolicy(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetResourcePolicy: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_GetShardIterator(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.GetShardIteratorInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetShardIterator(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetShardIterator: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_IncreaseStreamRetentionPeriod(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.IncreaseStreamRetentionPeriodInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.IncreaseStreamRetentionPeriod(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call IncreaseStreamRetentionPeriod: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_ListShards(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.ListShardsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListShards(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListShards: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_ListStreamConsumers(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.ListStreamConsumersInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListStreamConsumers(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListStreamConsumers: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_ListStreams(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.ListStreamsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListStreams(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListStreams: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_ListTagsForStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.ListTagsForStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListTagsForStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListTagsForStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_MergeShards(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.MergeShardsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.MergeShards(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call MergeShards: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_PutRecord(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.PutRecordInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutRecord(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutRecord: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_PutRecords(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.PutRecordsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutRecords(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutRecords: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_PutResourcePolicy(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.PutResourcePolicyInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutResourcePolicy(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutResourcePolicy: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_RegisterStreamConsumer(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.RegisterStreamConsumerInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RegisterStreamConsumer(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RegisterStreamConsumer: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_RemoveTagsFromStream(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.RemoveTagsFromStreamInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RemoveTagsFromStream(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RemoveTagsFromStream: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_SplitShard(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.SplitShardInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.SplitShard(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call SplitShard: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_StartStreamEncryption(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.StartStreamEncryptionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StartStreamEncryption(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StartStreamEncryption: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_StopStreamEncryption(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.StopStreamEncryptionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StopStreamEncryption(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StopStreamEncryption: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_SubscribeToShard(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.SubscribeToShardInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.SubscribeToShard(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call SubscribeToShard: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_UpdateShardCount(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.UpdateShardCountInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateShardCount(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateShardCount: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func kinesis_UpdateStreamMode(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := kinesis.NewFromConfig(awsCfg) + var in kinesis.UpdateStreamModeInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateStreamMode(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateStreamMode: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func init() { + clientMethods["kinesis_AddTagsToStream"] = kinesis_AddTagsToStream + clientMethods["kinesis_CreateStream"] = kinesis_CreateStream + clientMethods["kinesis_DecreaseStreamRetentionPeriod"] = kinesis_DecreaseStreamRetentionPeriod + clientMethods["kinesis_DeleteResourcePolicy"] = kinesis_DeleteResourcePolicy + clientMethods["kinesis_DeleteStream"] = kinesis_DeleteStream + clientMethods["kinesis_DeregisterStreamConsumer"] = kinesis_DeregisterStreamConsumer + clientMethods["kinesis_DescribeLimits"] = kinesis_DescribeLimits + clientMethods["kinesis_DescribeStream"] = kinesis_DescribeStream + clientMethods["kinesis_DescribeStreamConsumer"] = kinesis_DescribeStreamConsumer + clientMethods["kinesis_DescribeStreamSummary"] = kinesis_DescribeStreamSummary + clientMethods["kinesis_DisableEnhancedMonitoring"] = kinesis_DisableEnhancedMonitoring + clientMethods["kinesis_EnableEnhancedMonitoring"] = kinesis_EnableEnhancedMonitoring + clientMethods["kinesis_GetRecords"] = kinesis_GetRecords + clientMethods["kinesis_GetResourcePolicy"] = kinesis_GetResourcePolicy + clientMethods["kinesis_GetShardIterator"] = kinesis_GetShardIterator + clientMethods["kinesis_IncreaseStreamRetentionPeriod"] = kinesis_IncreaseStreamRetentionPeriod + clientMethods["kinesis_ListShards"] = kinesis_ListShards + clientMethods["kinesis_ListStreamConsumers"] = kinesis_ListStreamConsumers + clientMethods["kinesis_ListStreams"] = kinesis_ListStreams + clientMethods["kinesis_ListTagsForStream"] = kinesis_ListTagsForStream + clientMethods["kinesis_MergeShards"] = kinesis_MergeShards + clientMethods["kinesis_PutRecord"] = kinesis_PutRecord + clientMethods["kinesis_PutRecords"] = kinesis_PutRecords + clientMethods["kinesis_PutResourcePolicy"] = kinesis_PutResourcePolicy + clientMethods["kinesis_RegisterStreamConsumer"] = kinesis_RegisterStreamConsumer + clientMethods["kinesis_RemoveTagsFromStream"] = kinesis_RemoveTagsFromStream + clientMethods["kinesis_SplitShard"] = kinesis_SplitShard + clientMethods["kinesis_StartStreamEncryption"] = kinesis_StartStreamEncryption + clientMethods["kinesis_StopStreamEncryption"] = kinesis_StopStreamEncryption + clientMethods["kinesis_SubscribeToShard"] = kinesis_SubscribeToShard + clientMethods["kinesis_UpdateShardCount"] = kinesis_UpdateShardCount + clientMethods["kinesis_UpdateStreamMode"] = kinesis_UpdateStreamMode +} diff --git a/main.go b/main.go new file mode 100644 index 0000000..440a9cb --- /dev/null +++ b/main.go @@ -0,0 +1,75 @@ +package sdkclient + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "os" + "sort" + "strings" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/config" +) + +var awsCfg aws.Config + +var clientMethods = make(map[string]func(context.Context, json.RawMessage) (json.RawMessage, error)) + +func Run(ctx context.Context) error { + var err error + awsCfg, err = config.LoadDefaultConfig(ctx) + if err != nil { + return err + } + switch len(os.Args) { + case 1: + return fmt.Errorf("no args") + case 2: + pkgName := os.Args[1] + return listMethods(pkgName) + case 3: + pkgName := os.Args[1] + methodName := os.Args[2] + input := json.RawMessage(`{}`) + return dispatchMethod(ctx, pkgName, methodName, input) + case 4: + pkgName := os.Args[1] + methodName := os.Args[2] + input := json.RawMessage(os.Args[3]) + return dispatchMethod(ctx, pkgName, methodName, input) + default: + return fmt.Errorf("too many args") + } +} + +func dispatchMethod(ctx context.Context, pkgName, methodName string, in json.RawMessage) error { + fn := clientMethods[pkgName+"_"+methodName] + if fn == nil { + return fmt.Errorf("unknown method %s of %s", methodName, pkgName) + } + out, err := fn(ctx, in) + if err != nil { + return err + } + var buf bytes.Buffer + json.Indent(&buf, out, "", " ") + buf.WriteTo(os.Stdout) + fmt.Fprintln(os.Stdout) + return nil +} + +func listMethods(pkgName string) error { + methods := make([]string, 0) + for name := range clientMethods { + if strings.HasPrefix(name, pkgName+"_") { + methods = append(methods, strings.TrimPrefix(name, pkgName+"_")) + } + } + sort.Strings(methods) + for _, name := range methods { + fmt.Println(name) + } + return nil +} diff --git a/ssm_gen.go b/ssm_gen.go new file mode 100644 index 0000000..fe31ef8 --- /dev/null +++ b/ssm_gen.go @@ -0,0 +1,2531 @@ +package sdkclient + +import ( + "context" + "encoding/json" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/ssm" +) + +func ssm_AddTagsToResource(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.AddTagsToResourceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.AddTagsToResource(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call AddTagsToResource: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_AssociateOpsItemRelatedItem(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.AssociateOpsItemRelatedItemInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.AssociateOpsItemRelatedItem(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call AssociateOpsItemRelatedItem: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CancelCommand(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CancelCommandInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CancelCommand(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CancelCommand: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CancelMaintenanceWindowExecution(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CancelMaintenanceWindowExecutionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CancelMaintenanceWindowExecution(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CancelMaintenanceWindowExecution: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreateActivation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreateActivationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateActivation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateActivation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreateAssociation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreateAssociationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateAssociation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateAssociation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreateAssociationBatch(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreateAssociationBatchInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateAssociationBatch(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateAssociationBatch: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreateDocument(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreateDocumentInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateDocument(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateDocument: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreateMaintenanceWindow(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreateMaintenanceWindowInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateMaintenanceWindow(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateMaintenanceWindow: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreateOpsItem(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreateOpsItemInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateOpsItem(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateOpsItem: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreateOpsMetadata(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreateOpsMetadataInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateOpsMetadata(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateOpsMetadata: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreatePatchBaseline(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreatePatchBaselineInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreatePatchBaseline(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreatePatchBaseline: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_CreateResourceDataSync(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.CreateResourceDataSyncInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.CreateResourceDataSync(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call CreateResourceDataSync: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteActivation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteActivationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteActivation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteActivation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteAssociation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteAssociationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteAssociation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteAssociation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteDocument(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteDocumentInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteDocument(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteDocument: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteInventory(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteInventoryInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteInventory(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteInventory: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteMaintenanceWindow(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteMaintenanceWindowInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteMaintenanceWindow(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteMaintenanceWindow: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteOpsItem(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteOpsItemInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteOpsItem(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteOpsItem: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteOpsMetadata(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteOpsMetadataInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteOpsMetadata(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteOpsMetadata: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteParameter(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteParameterInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteParameter(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteParameter: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteParameters(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteParametersInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteParameters(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteParameters: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeletePatchBaseline(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeletePatchBaselineInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeletePatchBaseline(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeletePatchBaseline: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteResourceDataSync(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteResourceDataSyncInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteResourceDataSync(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteResourceDataSync: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeleteResourcePolicy(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeleteResourcePolicyInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeleteResourcePolicy(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeleteResourcePolicy: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeregisterManagedInstance(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeregisterManagedInstanceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeregisterManagedInstance(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeregisterManagedInstance: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeregisterPatchBaselineForPatchGroup(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeregisterPatchBaselineForPatchGroupInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeregisterPatchBaselineForPatchGroup(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeregisterPatchBaselineForPatchGroup: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeregisterTargetFromMaintenanceWindow(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeregisterTargetFromMaintenanceWindowInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeregisterTargetFromMaintenanceWindow(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeregisterTargetFromMaintenanceWindow: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DeregisterTaskFromMaintenanceWindow(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DeregisterTaskFromMaintenanceWindowInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DeregisterTaskFromMaintenanceWindow(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DeregisterTaskFromMaintenanceWindow: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeActivations(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeActivationsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeActivations(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeActivations: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeAssociation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeAssociationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeAssociation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeAssociation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeAssociationExecutionTargets(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeAssociationExecutionTargetsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeAssociationExecutionTargets(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeAssociationExecutionTargets: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeAssociationExecutions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeAssociationExecutionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeAssociationExecutions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeAssociationExecutions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeAutomationExecutions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeAutomationExecutionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeAutomationExecutions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeAutomationExecutions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeAutomationStepExecutions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeAutomationStepExecutionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeAutomationStepExecutions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeAutomationStepExecutions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeAvailablePatches(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeAvailablePatchesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeAvailablePatches(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeAvailablePatches: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeDocument(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeDocumentInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeDocument(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeDocument: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeDocumentPermission(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeDocumentPermissionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeDocumentPermission(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeDocumentPermission: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeEffectiveInstanceAssociations(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeEffectiveInstanceAssociationsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeEffectiveInstanceAssociations(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeEffectiveInstanceAssociations: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeEffectivePatchesForPatchBaseline(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeEffectivePatchesForPatchBaselineInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeEffectivePatchesForPatchBaseline(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeEffectivePatchesForPatchBaseline: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeInstanceAssociationsStatus(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeInstanceAssociationsStatusInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeInstanceAssociationsStatus(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeInstanceAssociationsStatus: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeInstanceInformation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeInstanceInformationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeInstanceInformation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeInstanceInformation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeInstancePatchStates(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeInstancePatchStatesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeInstancePatchStates(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeInstancePatchStates: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeInstancePatchStatesForPatchGroup(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeInstancePatchStatesForPatchGroupInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeInstancePatchStatesForPatchGroup(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeInstancePatchStatesForPatchGroup: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeInstancePatches(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeInstancePatchesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeInstancePatches(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeInstancePatches: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeInstanceProperties(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeInstancePropertiesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeInstanceProperties(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeInstanceProperties: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeInventoryDeletions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeInventoryDeletionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeInventoryDeletions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeInventoryDeletions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeMaintenanceWindowExecutionTaskInvocations(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeMaintenanceWindowExecutionTaskInvocationsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeMaintenanceWindowExecutionTaskInvocations(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeMaintenanceWindowExecutionTaskInvocations: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeMaintenanceWindowExecutionTasks(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeMaintenanceWindowExecutionTasksInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeMaintenanceWindowExecutionTasks(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeMaintenanceWindowExecutionTasks: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeMaintenanceWindowExecutions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeMaintenanceWindowExecutionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeMaintenanceWindowExecutions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeMaintenanceWindowExecutions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeMaintenanceWindowSchedule(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeMaintenanceWindowScheduleInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeMaintenanceWindowSchedule(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeMaintenanceWindowSchedule: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeMaintenanceWindowTargets(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeMaintenanceWindowTargetsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeMaintenanceWindowTargets(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeMaintenanceWindowTargets: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeMaintenanceWindowTasks(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeMaintenanceWindowTasksInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeMaintenanceWindowTasks(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeMaintenanceWindowTasks: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeMaintenanceWindows(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeMaintenanceWindowsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeMaintenanceWindows(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeMaintenanceWindows: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeMaintenanceWindowsForTarget(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeMaintenanceWindowsForTargetInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeMaintenanceWindowsForTarget(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeMaintenanceWindowsForTarget: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeOpsItems(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeOpsItemsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeOpsItems(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeOpsItems: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeParameters(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeParametersInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeParameters(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeParameters: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribePatchBaselines(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribePatchBaselinesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribePatchBaselines(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribePatchBaselines: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribePatchGroupState(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribePatchGroupStateInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribePatchGroupState(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribePatchGroupState: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribePatchGroups(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribePatchGroupsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribePatchGroups(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribePatchGroups: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribePatchProperties(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribePatchPropertiesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribePatchProperties(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribePatchProperties: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DescribeSessions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DescribeSessionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DescribeSessions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DescribeSessions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_DisassociateOpsItemRelatedItem(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.DisassociateOpsItemRelatedItemInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.DisassociateOpsItemRelatedItem(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call DisassociateOpsItemRelatedItem: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetAutomationExecution(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetAutomationExecutionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetAutomationExecution(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetAutomationExecution: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetCalendarState(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetCalendarStateInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetCalendarState(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetCalendarState: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetCommandInvocation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetCommandInvocationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetCommandInvocation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetCommandInvocation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetConnectionStatus(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetConnectionStatusInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetConnectionStatus(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetConnectionStatus: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetDefaultPatchBaseline(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetDefaultPatchBaselineInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetDefaultPatchBaseline(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetDefaultPatchBaseline: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetDeployablePatchSnapshotForInstance(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetDeployablePatchSnapshotForInstanceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetDeployablePatchSnapshotForInstance(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetDeployablePatchSnapshotForInstance: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetDocument(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetDocumentInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetDocument(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetDocument: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetInventory(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetInventoryInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetInventory(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetInventory: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetInventorySchema(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetInventorySchemaInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetInventorySchema(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetInventorySchema: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetMaintenanceWindow(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetMaintenanceWindowInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetMaintenanceWindow(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetMaintenanceWindow: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetMaintenanceWindowExecution(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetMaintenanceWindowExecutionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetMaintenanceWindowExecution(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetMaintenanceWindowExecution: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetMaintenanceWindowExecutionTask(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetMaintenanceWindowExecutionTaskInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetMaintenanceWindowExecutionTask(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetMaintenanceWindowExecutionTask: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetMaintenanceWindowExecutionTaskInvocation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetMaintenanceWindowExecutionTaskInvocationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetMaintenanceWindowExecutionTaskInvocation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetMaintenanceWindowExecutionTaskInvocation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetMaintenanceWindowTask(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetMaintenanceWindowTaskInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetMaintenanceWindowTask(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetMaintenanceWindowTask: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetOpsItem(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetOpsItemInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetOpsItem(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetOpsItem: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetOpsMetadata(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetOpsMetadataInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetOpsMetadata(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetOpsMetadata: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetOpsSummary(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetOpsSummaryInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetOpsSummary(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetOpsSummary: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetParameter(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetParameterInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetParameter(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetParameter: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetParameterHistory(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetParameterHistoryInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetParameterHistory(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetParameterHistory: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetParameters(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetParametersInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetParameters(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetParameters: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetParametersByPath(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetParametersByPathInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetParametersByPath(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetParametersByPath: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetPatchBaseline(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetPatchBaselineInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetPatchBaseline(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetPatchBaseline: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetPatchBaselineForPatchGroup(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetPatchBaselineForPatchGroupInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetPatchBaselineForPatchGroup(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetPatchBaselineForPatchGroup: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetResourcePolicies(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetResourcePoliciesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetResourcePolicies(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetResourcePolicies: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_GetServiceSetting(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.GetServiceSettingInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.GetServiceSetting(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call GetServiceSetting: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_LabelParameterVersion(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.LabelParameterVersionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.LabelParameterVersion(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call LabelParameterVersion: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListAssociationVersions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListAssociationVersionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListAssociationVersions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListAssociationVersions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListAssociations(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListAssociationsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListAssociations(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListAssociations: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListCommandInvocations(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListCommandInvocationsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListCommandInvocations(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListCommandInvocations: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListCommands(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListCommandsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListCommands(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListCommands: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListComplianceItems(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListComplianceItemsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListComplianceItems(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListComplianceItems: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListComplianceSummaries(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListComplianceSummariesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListComplianceSummaries(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListComplianceSummaries: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListDocumentMetadataHistory(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListDocumentMetadataHistoryInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListDocumentMetadataHistory(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListDocumentMetadataHistory: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListDocumentVersions(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListDocumentVersionsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListDocumentVersions(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListDocumentVersions: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListDocuments(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListDocumentsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListDocuments(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListDocuments: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListInventoryEntries(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListInventoryEntriesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListInventoryEntries(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListInventoryEntries: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListOpsItemEvents(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListOpsItemEventsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListOpsItemEvents(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListOpsItemEvents: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListOpsItemRelatedItems(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListOpsItemRelatedItemsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListOpsItemRelatedItems(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListOpsItemRelatedItems: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListOpsMetadata(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListOpsMetadataInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListOpsMetadata(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListOpsMetadata: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListResourceComplianceSummaries(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListResourceComplianceSummariesInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListResourceComplianceSummaries(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListResourceComplianceSummaries: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListResourceDataSync(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListResourceDataSyncInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListResourceDataSync(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListResourceDataSync: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ListTagsForResource(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ListTagsForResourceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ListTagsForResource(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ListTagsForResource: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ModifyDocumentPermission(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ModifyDocumentPermissionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ModifyDocumentPermission(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ModifyDocumentPermission: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_PutComplianceItems(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.PutComplianceItemsInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutComplianceItems(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutComplianceItems: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_PutInventory(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.PutInventoryInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutInventory(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutInventory: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_PutParameter(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.PutParameterInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutParameter(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutParameter: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_PutResourcePolicy(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.PutResourcePolicyInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.PutResourcePolicy(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call PutResourcePolicy: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_RegisterDefaultPatchBaseline(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.RegisterDefaultPatchBaselineInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RegisterDefaultPatchBaseline(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RegisterDefaultPatchBaseline: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_RegisterPatchBaselineForPatchGroup(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.RegisterPatchBaselineForPatchGroupInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RegisterPatchBaselineForPatchGroup(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RegisterPatchBaselineForPatchGroup: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_RegisterTargetWithMaintenanceWindow(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.RegisterTargetWithMaintenanceWindowInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RegisterTargetWithMaintenanceWindow(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RegisterTargetWithMaintenanceWindow: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_RegisterTaskWithMaintenanceWindow(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.RegisterTaskWithMaintenanceWindowInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RegisterTaskWithMaintenanceWindow(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RegisterTaskWithMaintenanceWindow: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_RemoveTagsFromResource(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.RemoveTagsFromResourceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.RemoveTagsFromResource(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call RemoveTagsFromResource: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ResetServiceSetting(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ResetServiceSettingInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ResetServiceSetting(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ResetServiceSetting: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_ResumeSession(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.ResumeSessionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.ResumeSession(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call ResumeSession: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_SendAutomationSignal(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.SendAutomationSignalInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.SendAutomationSignal(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call SendAutomationSignal: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_SendCommand(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.SendCommandInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.SendCommand(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call SendCommand: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_StartAssociationsOnce(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.StartAssociationsOnceInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StartAssociationsOnce(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StartAssociationsOnce: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_StartAutomationExecution(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.StartAutomationExecutionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StartAutomationExecution(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StartAutomationExecution: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_StartChangeRequestExecution(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.StartChangeRequestExecutionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StartChangeRequestExecution(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StartChangeRequestExecution: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_StartSession(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.StartSessionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StartSession(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StartSession: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_StopAutomationExecution(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.StopAutomationExecutionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.StopAutomationExecution(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call StopAutomationExecution: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_TerminateSession(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.TerminateSessionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.TerminateSession(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call TerminateSession: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UnlabelParameterVersion(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UnlabelParameterVersionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UnlabelParameterVersion(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UnlabelParameterVersion: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateAssociation(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateAssociationInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateAssociation(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateAssociation: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateAssociationStatus(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateAssociationStatusInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateAssociationStatus(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateAssociationStatus: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateDocument(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateDocumentInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateDocument(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateDocument: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateDocumentDefaultVersion(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateDocumentDefaultVersionInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateDocumentDefaultVersion(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateDocumentDefaultVersion: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateDocumentMetadata(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateDocumentMetadataInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateDocumentMetadata(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateDocumentMetadata: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateMaintenanceWindow(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateMaintenanceWindowInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateMaintenanceWindow(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateMaintenanceWindow: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateMaintenanceWindowTarget(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateMaintenanceWindowTargetInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateMaintenanceWindowTarget(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateMaintenanceWindowTarget: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateMaintenanceWindowTask(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateMaintenanceWindowTaskInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateMaintenanceWindowTask(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateMaintenanceWindowTask: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateManagedInstanceRole(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateManagedInstanceRoleInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateManagedInstanceRole(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateManagedInstanceRole: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateOpsItem(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateOpsItemInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateOpsItem(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateOpsItem: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateOpsMetadata(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateOpsMetadataInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateOpsMetadata(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateOpsMetadata: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdatePatchBaseline(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdatePatchBaselineInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdatePatchBaseline(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdatePatchBaseline: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateResourceDataSync(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateResourceDataSyncInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateResourceDataSync(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateResourceDataSync: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func ssm_UpdateServiceSetting(ctx context.Context, b json.RawMessage) (json.RawMessage, error) { + svc := ssm.NewFromConfig(awsCfg) + var in ssm.UpdateServiceSettingInput + if err := json.Unmarshal(b, &in); err != nil { + return nil, fmt.Errorf("failed to unmarshal request: %w", err) + } + if out, err := svc.UpdateServiceSetting(ctx, &in); err != nil { + return nil, fmt.Errorf("failed to call UpdateServiceSetting: %w", err) + } else { + o, err := json.Marshal(out) + if err != nil { + return nil, fmt.Errorf("failed to marshal response: %w", err) + } + return o, nil + } +} + +func init() { + clientMethods["ssm_AddTagsToResource"] = ssm_AddTagsToResource + clientMethods["ssm_AssociateOpsItemRelatedItem"] = ssm_AssociateOpsItemRelatedItem + clientMethods["ssm_CancelCommand"] = ssm_CancelCommand + clientMethods["ssm_CancelMaintenanceWindowExecution"] = ssm_CancelMaintenanceWindowExecution + clientMethods["ssm_CreateActivation"] = ssm_CreateActivation + clientMethods["ssm_CreateAssociation"] = ssm_CreateAssociation + clientMethods["ssm_CreateAssociationBatch"] = ssm_CreateAssociationBatch + clientMethods["ssm_CreateDocument"] = ssm_CreateDocument + clientMethods["ssm_CreateMaintenanceWindow"] = ssm_CreateMaintenanceWindow + clientMethods["ssm_CreateOpsItem"] = ssm_CreateOpsItem + clientMethods["ssm_CreateOpsMetadata"] = ssm_CreateOpsMetadata + clientMethods["ssm_CreatePatchBaseline"] = ssm_CreatePatchBaseline + clientMethods["ssm_CreateResourceDataSync"] = ssm_CreateResourceDataSync + clientMethods["ssm_DeleteActivation"] = ssm_DeleteActivation + clientMethods["ssm_DeleteAssociation"] = ssm_DeleteAssociation + clientMethods["ssm_DeleteDocument"] = ssm_DeleteDocument + clientMethods["ssm_DeleteInventory"] = ssm_DeleteInventory + clientMethods["ssm_DeleteMaintenanceWindow"] = ssm_DeleteMaintenanceWindow + clientMethods["ssm_DeleteOpsItem"] = ssm_DeleteOpsItem + clientMethods["ssm_DeleteOpsMetadata"] = ssm_DeleteOpsMetadata + clientMethods["ssm_DeleteParameter"] = ssm_DeleteParameter + clientMethods["ssm_DeleteParameters"] = ssm_DeleteParameters + clientMethods["ssm_DeletePatchBaseline"] = ssm_DeletePatchBaseline + clientMethods["ssm_DeleteResourceDataSync"] = ssm_DeleteResourceDataSync + clientMethods["ssm_DeleteResourcePolicy"] = ssm_DeleteResourcePolicy + clientMethods["ssm_DeregisterManagedInstance"] = ssm_DeregisterManagedInstance + clientMethods["ssm_DeregisterPatchBaselineForPatchGroup"] = ssm_DeregisterPatchBaselineForPatchGroup + clientMethods["ssm_DeregisterTargetFromMaintenanceWindow"] = ssm_DeregisterTargetFromMaintenanceWindow + clientMethods["ssm_DeregisterTaskFromMaintenanceWindow"] = ssm_DeregisterTaskFromMaintenanceWindow + clientMethods["ssm_DescribeActivations"] = ssm_DescribeActivations + clientMethods["ssm_DescribeAssociation"] = ssm_DescribeAssociation + clientMethods["ssm_DescribeAssociationExecutionTargets"] = ssm_DescribeAssociationExecutionTargets + clientMethods["ssm_DescribeAssociationExecutions"] = ssm_DescribeAssociationExecutions + clientMethods["ssm_DescribeAutomationExecutions"] = ssm_DescribeAutomationExecutions + clientMethods["ssm_DescribeAutomationStepExecutions"] = ssm_DescribeAutomationStepExecutions + clientMethods["ssm_DescribeAvailablePatches"] = ssm_DescribeAvailablePatches + clientMethods["ssm_DescribeDocument"] = ssm_DescribeDocument + clientMethods["ssm_DescribeDocumentPermission"] = ssm_DescribeDocumentPermission + clientMethods["ssm_DescribeEffectiveInstanceAssociations"] = ssm_DescribeEffectiveInstanceAssociations + clientMethods["ssm_DescribeEffectivePatchesForPatchBaseline"] = ssm_DescribeEffectivePatchesForPatchBaseline + clientMethods["ssm_DescribeInstanceAssociationsStatus"] = ssm_DescribeInstanceAssociationsStatus + clientMethods["ssm_DescribeInstanceInformation"] = ssm_DescribeInstanceInformation + clientMethods["ssm_DescribeInstancePatchStates"] = ssm_DescribeInstancePatchStates + clientMethods["ssm_DescribeInstancePatchStatesForPatchGroup"] = ssm_DescribeInstancePatchStatesForPatchGroup + clientMethods["ssm_DescribeInstancePatches"] = ssm_DescribeInstancePatches + clientMethods["ssm_DescribeInstanceProperties"] = ssm_DescribeInstanceProperties + clientMethods["ssm_DescribeInventoryDeletions"] = ssm_DescribeInventoryDeletions + clientMethods["ssm_DescribeMaintenanceWindowExecutionTaskInvocations"] = ssm_DescribeMaintenanceWindowExecutionTaskInvocations + clientMethods["ssm_DescribeMaintenanceWindowExecutionTasks"] = ssm_DescribeMaintenanceWindowExecutionTasks + clientMethods["ssm_DescribeMaintenanceWindowExecutions"] = ssm_DescribeMaintenanceWindowExecutions + clientMethods["ssm_DescribeMaintenanceWindowSchedule"] = ssm_DescribeMaintenanceWindowSchedule + clientMethods["ssm_DescribeMaintenanceWindowTargets"] = ssm_DescribeMaintenanceWindowTargets + clientMethods["ssm_DescribeMaintenanceWindowTasks"] = ssm_DescribeMaintenanceWindowTasks + clientMethods["ssm_DescribeMaintenanceWindows"] = ssm_DescribeMaintenanceWindows + clientMethods["ssm_DescribeMaintenanceWindowsForTarget"] = ssm_DescribeMaintenanceWindowsForTarget + clientMethods["ssm_DescribeOpsItems"] = ssm_DescribeOpsItems + clientMethods["ssm_DescribeParameters"] = ssm_DescribeParameters + clientMethods["ssm_DescribePatchBaselines"] = ssm_DescribePatchBaselines + clientMethods["ssm_DescribePatchGroupState"] = ssm_DescribePatchGroupState + clientMethods["ssm_DescribePatchGroups"] = ssm_DescribePatchGroups + clientMethods["ssm_DescribePatchProperties"] = ssm_DescribePatchProperties + clientMethods["ssm_DescribeSessions"] = ssm_DescribeSessions + clientMethods["ssm_DisassociateOpsItemRelatedItem"] = ssm_DisassociateOpsItemRelatedItem + clientMethods["ssm_GetAutomationExecution"] = ssm_GetAutomationExecution + clientMethods["ssm_GetCalendarState"] = ssm_GetCalendarState + clientMethods["ssm_GetCommandInvocation"] = ssm_GetCommandInvocation + clientMethods["ssm_GetConnectionStatus"] = ssm_GetConnectionStatus + clientMethods["ssm_GetDefaultPatchBaseline"] = ssm_GetDefaultPatchBaseline + clientMethods["ssm_GetDeployablePatchSnapshotForInstance"] = ssm_GetDeployablePatchSnapshotForInstance + clientMethods["ssm_GetDocument"] = ssm_GetDocument + clientMethods["ssm_GetInventory"] = ssm_GetInventory + clientMethods["ssm_GetInventorySchema"] = ssm_GetInventorySchema + clientMethods["ssm_GetMaintenanceWindow"] = ssm_GetMaintenanceWindow + clientMethods["ssm_GetMaintenanceWindowExecution"] = ssm_GetMaintenanceWindowExecution + clientMethods["ssm_GetMaintenanceWindowExecutionTask"] = ssm_GetMaintenanceWindowExecutionTask + clientMethods["ssm_GetMaintenanceWindowExecutionTaskInvocation"] = ssm_GetMaintenanceWindowExecutionTaskInvocation + clientMethods["ssm_GetMaintenanceWindowTask"] = ssm_GetMaintenanceWindowTask + clientMethods["ssm_GetOpsItem"] = ssm_GetOpsItem + clientMethods["ssm_GetOpsMetadata"] = ssm_GetOpsMetadata + clientMethods["ssm_GetOpsSummary"] = ssm_GetOpsSummary + clientMethods["ssm_GetParameter"] = ssm_GetParameter + clientMethods["ssm_GetParameterHistory"] = ssm_GetParameterHistory + clientMethods["ssm_GetParameters"] = ssm_GetParameters + clientMethods["ssm_GetParametersByPath"] = ssm_GetParametersByPath + clientMethods["ssm_GetPatchBaseline"] = ssm_GetPatchBaseline + clientMethods["ssm_GetPatchBaselineForPatchGroup"] = ssm_GetPatchBaselineForPatchGroup + clientMethods["ssm_GetResourcePolicies"] = ssm_GetResourcePolicies + clientMethods["ssm_GetServiceSetting"] = ssm_GetServiceSetting + clientMethods["ssm_LabelParameterVersion"] = ssm_LabelParameterVersion + clientMethods["ssm_ListAssociationVersions"] = ssm_ListAssociationVersions + clientMethods["ssm_ListAssociations"] = ssm_ListAssociations + clientMethods["ssm_ListCommandInvocations"] = ssm_ListCommandInvocations + clientMethods["ssm_ListCommands"] = ssm_ListCommands + clientMethods["ssm_ListComplianceItems"] = ssm_ListComplianceItems + clientMethods["ssm_ListComplianceSummaries"] = ssm_ListComplianceSummaries + clientMethods["ssm_ListDocumentMetadataHistory"] = ssm_ListDocumentMetadataHistory + clientMethods["ssm_ListDocumentVersions"] = ssm_ListDocumentVersions + clientMethods["ssm_ListDocuments"] = ssm_ListDocuments + clientMethods["ssm_ListInventoryEntries"] = ssm_ListInventoryEntries + clientMethods["ssm_ListOpsItemEvents"] = ssm_ListOpsItemEvents + clientMethods["ssm_ListOpsItemRelatedItems"] = ssm_ListOpsItemRelatedItems + clientMethods["ssm_ListOpsMetadata"] = ssm_ListOpsMetadata + clientMethods["ssm_ListResourceComplianceSummaries"] = ssm_ListResourceComplianceSummaries + clientMethods["ssm_ListResourceDataSync"] = ssm_ListResourceDataSync + clientMethods["ssm_ListTagsForResource"] = ssm_ListTagsForResource + clientMethods["ssm_ModifyDocumentPermission"] = ssm_ModifyDocumentPermission + clientMethods["ssm_PutComplianceItems"] = ssm_PutComplianceItems + clientMethods["ssm_PutInventory"] = ssm_PutInventory + clientMethods["ssm_PutParameter"] = ssm_PutParameter + clientMethods["ssm_PutResourcePolicy"] = ssm_PutResourcePolicy + clientMethods["ssm_RegisterDefaultPatchBaseline"] = ssm_RegisterDefaultPatchBaseline + clientMethods["ssm_RegisterPatchBaselineForPatchGroup"] = ssm_RegisterPatchBaselineForPatchGroup + clientMethods["ssm_RegisterTargetWithMaintenanceWindow"] = ssm_RegisterTargetWithMaintenanceWindow + clientMethods["ssm_RegisterTaskWithMaintenanceWindow"] = ssm_RegisterTaskWithMaintenanceWindow + clientMethods["ssm_RemoveTagsFromResource"] = ssm_RemoveTagsFromResource + clientMethods["ssm_ResetServiceSetting"] = ssm_ResetServiceSetting + clientMethods["ssm_ResumeSession"] = ssm_ResumeSession + clientMethods["ssm_SendAutomationSignal"] = ssm_SendAutomationSignal + clientMethods["ssm_SendCommand"] = ssm_SendCommand + clientMethods["ssm_StartAssociationsOnce"] = ssm_StartAssociationsOnce + clientMethods["ssm_StartAutomationExecution"] = ssm_StartAutomationExecution + clientMethods["ssm_StartChangeRequestExecution"] = ssm_StartChangeRequestExecution + clientMethods["ssm_StartSession"] = ssm_StartSession + clientMethods["ssm_StopAutomationExecution"] = ssm_StopAutomationExecution + clientMethods["ssm_TerminateSession"] = ssm_TerminateSession + clientMethods["ssm_UnlabelParameterVersion"] = ssm_UnlabelParameterVersion + clientMethods["ssm_UpdateAssociation"] = ssm_UpdateAssociation + clientMethods["ssm_UpdateAssociationStatus"] = ssm_UpdateAssociationStatus + clientMethods["ssm_UpdateDocument"] = ssm_UpdateDocument + clientMethods["ssm_UpdateDocumentDefaultVersion"] = ssm_UpdateDocumentDefaultVersion + clientMethods["ssm_UpdateDocumentMetadata"] = ssm_UpdateDocumentMetadata + clientMethods["ssm_UpdateMaintenanceWindow"] = ssm_UpdateMaintenanceWindow + clientMethods["ssm_UpdateMaintenanceWindowTarget"] = ssm_UpdateMaintenanceWindowTarget + clientMethods["ssm_UpdateMaintenanceWindowTask"] = ssm_UpdateMaintenanceWindowTask + clientMethods["ssm_UpdateManagedInstanceRole"] = ssm_UpdateManagedInstanceRole + clientMethods["ssm_UpdateOpsItem"] = ssm_UpdateOpsItem + clientMethods["ssm_UpdateOpsMetadata"] = ssm_UpdateOpsMetadata + clientMethods["ssm_UpdatePatchBaseline"] = ssm_UpdatePatchBaseline + clientMethods["ssm_UpdateResourceDataSync"] = ssm_UpdateResourceDataSync + clientMethods["ssm_UpdateServiceSetting"] = ssm_UpdateServiceSetting +}