diff --git a/README.md b/README.md index 76226fcf..7f17f77a 100644 --- a/README.md +++ b/README.md @@ -23,8 +23,8 @@ Today DevCloud targets **AWS**. Our long-term goal is to support the full range ## Features -- **148 AWS services registered, 117 serving at least one operation** — the other 31 are routed and decline with a clean AWS error rather than letting the call bill a real AWS account. The split is the honest form of the number; see [coverage.md](docs/coverage.md) for what it does and does not promise, and [services-matrix.md](docs/services-matrix.md) for the list -- **boto3-compatible** — a 729-test compatibility suite runs in CI (`make test-compat`); works with most boto3 apps, and unsupported operations return a clean AWS error, never a false success +- **205 AWS services registered, 201 serving at least one operation** — the other 4 are routed and decline with a clean AWS error rather than letting the call bill a real AWS account. The split is the honest form of the number; see [coverage.md](docs/coverage.md) for what it does and does not promise, and [services-matrix.md](docs/services-matrix.md) for the list +- **boto3-compatible** — a 992-test compatibility suite runs in CI (`make test-compat`) and exercises every registered service; works with most boto3 apps, and unsupported operations return a clean AWS error, never a false success - **Cross-service integration** — CFN provisioning, DDB Streams → Lambda, EventBridge targets, S3 → Lambda - **Smithy-driven codegen** — auto-generate Go types, routers, and error catalogues from Smithy models - **Weekly auto-sync** — GitHub Actions keeps generated code up to date with upstream AWS API changes diff --git a/changes/unreleased/Added-20260906-100000.yaml b/changes/unreleased/Added-20260906-100000.yaml new file mode 100644 index 00000000..1a8d778c --- /dev/null +++ b/changes/unreleased/Added-20260906-100000.yaml @@ -0,0 +1,5 @@ +kind: Added +body: 'CI gates the published coverage figure. `docs/coverage.md`, `README.md` and `docs/README.md` are read by `go test ./cmd/devcloud/` and compared to the live registry and fidelity manifest in both directions: removing a service without editing the published number fails, and editing the number without the code moving fails identically. The demand set in `docs/demand.md` is checked to still be registered, so the count cannot be held steady by swapping one service for another' +time: 2026-09-06T10:00:00.000000+09:00 +custom: + Issue: "144" diff --git a/changes/unreleased/Changed-20260906-100100.yaml b/changes/unreleased/Changed-20260906-100100.yaml new file mode 100644 index 00000000..7f147088 --- /dev/null +++ b/changes/unreleased/Changed-20260906-100100.yaml @@ -0,0 +1,5 @@ +kind: Changed +body: 'The boto3 compatibility suite exercises every registered service. It parametrises over a generated service list (`internal/generated/compat/services.json`) instead of two hand-written name lists, so registering a service and testing it are no longer separate steps. 31 of 205 registered services had no boto3 test at all, 29 of them counted in the published coverage figure; the suite grew from 854 to 993 tests' +time: 2026-09-06T10:01:00.000000+09:00 +custom: + Issue: "144" diff --git a/changes/unreleased/Documentation-20260906-100200.yaml b/changes/unreleased/Documentation-20260906-100200.yaml new file mode 100644 index 00000000..6ffa4d91 --- /dev/null +++ b/changes/unreleased/Documentation-20260906-100200.yaml @@ -0,0 +1,5 @@ +kind: Documentation +body: 'Coverage docs state what the compatibility figure excludes and why. Two registered services have no boto3 client at all (`sagemakerruntimehttp2`, `transcribestreaming`), and the four Lex services are registered but reachable by no boto3 caller — all four clients sign as the contested alias `lex`, which routes nowhere by design. `README.md` and `docs/README.md` had quoted 148 registered / 117 serving since three milestones earlier' +time: 2026-09-06T10:02:00.000000+09:00 +custom: + Issue: "144" diff --git a/cmd/codegen/main.go b/cmd/codegen/main.go index 71de76fb..230c7645 100644 --- a/cmd/codegen/main.go +++ b/cmd/codegen/main.go @@ -158,11 +158,21 @@ func main() { os.Exit(1) } - if err := writeFidelityManifest(gen, *outputDir, modelOps, protocols, providers, crudServices); err != nil { + // Built once and shared: the compat manifest is a projection of the + // fidelity data, so deriving it from anything else would let the two + // disagree about which operations a service serves. + fidelityData := codegen.BuildFidelityData(modelOps, protocols, providers, crudServices) + + if err := writeFidelityManifest(gen, *outputDir, fidelityData); err != nil { fmt.Fprintf(os.Stderr, "Error writing fidelity manifest: %v\n", err) os.Exit(1) } + if err := writeCompatManifest(*outputDir, fidelityData); err != nil { + fmt.Fprintf(os.Stderr, "Error writing compat manifest: %v\n", err) + os.Exit(1) + } + if err := writeAliases(gen, *outputDir, allModels); err != nil { fmt.Fprintf(os.Stderr, "Error writing alias table: %v\n", err) os.Exit(1) @@ -200,17 +210,8 @@ func writeAliases(gen *codegen.Generator, outputDir string, models []*ir.Model) // writeFidelityManifest emits the per-operation fidelity manifest. Like the CRUD // registry it is only written on a full-fleet run, since a filtered run would // produce a partial manifest. -func writeFidelityManifest( - gen *codegen.Generator, - outputDir string, - modelOps map[string][]string, - protocols map[string]string, - providers map[string]codegen.ProviderScan, - crudServices []codegen.CRUDServiceData, -) error { - content, err := gen.GenerateFidelityManifest( - codegen.BuildFidelityData(modelOps, protocols, providers, crudServices), - ) +func writeFidelityManifest(gen *codegen.Generator, outputDir string, data codegen.FidelityData) error { + content, err := gen.GenerateFidelityManifest(data) if err != nil { return err } @@ -221,3 +222,21 @@ func writeFidelityManifest( } return codegen.WriteGo(filepath.Join(dir, "manifest_gen.go"), content) } + +// writeCompatManifest emits the service list the boto3 compatibility suite +// parametrizes over. It is JSON rather than Go because Python reads it, and it +// lives under internal/generated so the codegen-drift CI job diffs it alongside +// everything else derived from the models — a service added without a +// regeneration then fails CI instead of quietly going untested. +func writeCompatManifest(outputDir string, data codegen.FidelityData) error { + content, err := codegen.RenderCompatManifest(codegen.BuildCompatManifest(data)) + if err != nil { + return err + } + + dir := filepath.Join(outputDir, "compat") + if err := os.MkdirAll(dir, 0755); err != nil { + return err + } + return os.WriteFile(filepath.Join(dir, "services.json"), content, 0644) +} diff --git a/cmd/devcloud/conformance_test.go b/cmd/devcloud/conformance_test.go index 6c5601a9..02be0598 100644 --- a/cmd/devcloud/conformance_test.go +++ b/cmd/devcloud/conformance_test.go @@ -24,13 +24,14 @@ var validProtocols = map[plugin.ProtocolType]bool{ func TestServicePluginConformance(t *testing.T) { ids := plugin.DefaultRegistry.RegisteredServices() - // Conservative floor. Broken registration wiring (a mangled imports.go, - // init-order regression, a dropped Register) collapses the live surface far - // below this, so a constant catches it without the fragility of parsing - // imports.go at runtime. Raise it if the real count ever nears it. - const minServices = 50 - if len(ids) < minServices { - t.Fatalf("registered %d services, want >= %d", len(ids), minServices) + // The count itself is asserted exactly against the published figure in + // TestPublishedCoverageMatchesTheBinary, which is what catches broken + // registration wiring (a mangled imports.go, an init-order regression, a + // dropped Register). This only needs the surface to be non-empty before + // iterating it; a conservative floor of 50 here would be a second, weaker + // answer to a question that now has an exact one. + if len(ids) == 0 { + t.Fatal("no services registered; check cmd/devcloud/imports.go") } var prev string diff --git a/cmd/devcloud/coverage_test.go b/cmd/devcloud/coverage_test.go new file mode 100644 index 00000000..2d28ae52 --- /dev/null +++ b/cmd/devcloud/coverage_test.go @@ -0,0 +1,309 @@ +// SPDX-License-Identifier: Apache-2.0 + +package main + +import ( + "fmt" + "os" + "regexp" + "sort" + "strconv" + "strings" + "testing" + + "github.com/skyoo2003/devcloud/internal/generated/fidelity" + "github.com/skyoo2003/devcloud/internal/plugin" +) + +// coveragePath is the published claim this file gates. It is read rather than +// duplicated: a constant here would be a third place the number lives, and the +// doc would still be free to drift from it. +const coveragePath = "../../docs/coverage.md" + +// coverageRow matches one row of the summary table at the top of +// docs/coverage.md: +// +// | **Registered** | The gateway routes the service. … | **205** | +// +// The label is anchored to the row start so a number quoted in prose elsewhere +// on the page cannot be mistaken for the published figure. +func coverageRow(t *testing.T, doc, label string) int { + t.Helper() + + pattern := regexp.MustCompile(`(?m)^\|\s*\*\*` + regexp.QuoteMeta(label) + `\*\*\s*\|[^|]*\|\s*\*\*(\d+)\*\*\s*\|`) + matches := pattern.FindAllStringSubmatch(doc, -1) + if len(matches) != 1 { + t.Fatalf("docs/coverage.md: found %d rows for %q, want exactly 1. "+ + "The summary table was restructured; this gate reads it, so update the "+ + "pattern deliberately rather than letting the numbers stop being checked.", + len(matches), label) + } + + n, err := strconv.Atoi(matches[0][1]) + if err != nil { + t.Fatalf("docs/coverage.md: %q row has an unreadable number %q", label, matches[0][1]) + } + return n +} + +// tierRow matches one row of the per-operation table in docs/coverage.md: +// +// | `hand-verified` | 4,496 | +// +// Thousands separators are stripped: the doc is written for a reader, and the +// gate reads what the reader sees rather than asking the doc to be machine-shaped. +func tierRow(t *testing.T, doc, label string) int { + t.Helper() + + pattern := regexp.MustCompile("(?m)^\\|\\s*`" + regexp.QuoteMeta(label) + "`\\s*\\|\\s*([\\d,]+)\\s*\\|") + matches := pattern.FindAllStringSubmatch(doc, -1) + if len(matches) != 1 { + t.Fatalf("docs/coverage.md: found %d rows for tier %q, want exactly 1", len(matches), label) + } + + n, err := strconv.Atoi(strings.ReplaceAll(matches[0][1], ",", "")) + if err != nil { + t.Fatalf("docs/coverage.md: tier %q has an unreadable number %q", label, matches[0][1]) + } + return n +} + +// servedCounts splits the manifest the way docs/coverage.md publishes it. +func servedCounts() (serving int, registeredOnly []string) { + for id, svc := range fidelity.Services { + served := 0 + for _, tier := range svc.Operations { + if tier != fidelity.TierUnimplemented { + served++ + } + } + if served > 0 { + serving++ + continue + } + registeredOnly = append(registeredOnly, id) + } + sort.Strings(registeredOnly) + return serving, registeredOnly +} + +// TestPublishedCoverageMatchesTheBinary is Milestone 6's gate: CI fails if a +// registered service drops below the floor or the count regresses. +// +// It asserts in both directions at once, which is the property that makes it +// useful. Removing a service without editing the doc fails, because the registry +// no longer matches the published figure. Editing the doc without changing the +// code fails for the same reason. There is no way to move one without the other. +// +// The floors this replaces (minServices = 100, minOperations = 6000) were +// deliberately conservative, and right for what they were written to catch — a +// mangled generator or broken registration wiring. They cannot notice 205 +// becoming 150, which is what the published claim actually rests on. +func TestPublishedCoverageMatchesTheBinary(t *testing.T) { + raw, err := os.ReadFile(coveragePath) + if err != nil { + t.Fatalf("read the published coverage claim: %v", err) + } + doc := string(raw) + + registered := plugin.DefaultRegistry.RegisteredServices() + serving, registeredOnly := servedCounts() + + if got, want := len(registered), len(fidelity.Services); got != want { + t.Errorf("the registry holds %d services and the fidelity manifest %d; "+ + "run `make codegen`", got, want) + } + + if got, want := coverageRow(t, doc, "Registered"), len(registered); got != want { + t.Errorf("docs/coverage.md publishes %d registered services, the binary registers %d. "+ + "If a service was added or removed on purpose, the published figure moves in the "+ + "same commit — that is what this gate is for.", got, want) + } + + if got, want := coverageRow(t, doc, "Serving ≥1 operation"), serving; got != want { + t.Errorf("docs/coverage.md publishes %d services serving at least one operation, "+ + "the manifest reports %d", got, want) + } + + if got, want := coverageRow(t, doc, "Registered-only"), len(registeredOnly); got != want { + t.Errorf("docs/coverage.md publishes %d registered-only services, the manifest reports "+ + "%d: %v", got, want, registeredOnly) + } +} + +// TestPublishedOperationTiersMatchTheManifest gates the depth half of the claim. +// +// The service count alone is the number docs/coverage.md exists to stop anyone +// quoting on its own, so the per-tier split is gated with the same strictness. +// This is what replaces the minOperations = 6000 floor: a scan that silently +// dropped a provider used to stay far above 6,000 and is caught here. +func TestPublishedOperationTiersMatchTheManifest(t *testing.T) { + raw, err := os.ReadFile(coveragePath) + if err != nil { + t.Fatalf("read the published coverage claim: %v", err) + } + doc := string(raw) + + counts := map[fidelity.Tier]int{} + total := 0 + for _, svc := range fidelity.Services { + for _, tier := range svc.Operations { + counts[tier]++ + total++ + } + } + + for _, tier := range []fidelity.Tier{ + fidelity.TierHandVerified, + fidelity.TierAutoCRUD, + fidelity.TierUnimplemented, + } { + if got, want := tierRow(t, doc, string(tier)), counts[tier]; got != want { + t.Errorf("docs/coverage.md publishes %d %s operations, the manifest holds %d", + got, tier, want) + } + } + + published := regexp.MustCompile(`(?m)^\|\s*\*\*total known\*\*\s*\|\s*\*\*([\d,]+)\*\*\s*\|`). + FindStringSubmatch(doc) + if published == nil { + t.Fatal("docs/coverage.md: the 'total known' row did not parse") + } + want, _ := strconv.Atoi(strings.ReplaceAll(published[1], ",", "")) + if want != total { + t.Errorf("docs/coverage.md publishes %d known operations, the manifest holds %d", want, total) + } +} + +// TestRegisteredOnlyServicesAreNamedInTheDocs keeps the depth claim honest, not +// only the count. docs/coverage.md states that the services serving nothing are +// exactly the ones with no CRUD-shaped operation, and names them. A service +// that silently joins that set would leave the prose true-looking and wrong. +func TestRegisteredOnlyServicesAreNamedInTheDocs(t *testing.T) { + raw, err := os.ReadFile(coveragePath) + if err != nil { + t.Fatalf("read the published coverage claim: %v", err) + } + doc := string(raw) + + _, registeredOnly := servedCounts() + for _, id := range registeredOnly { + if !strings.Contains(doc, id) && !strings.Contains(doc, hyphenate(id)) { + t.Errorf("%s serves nothing but docs/coverage.md never names it. "+ + "The page states which services serve nothing and why; a service that "+ + "joins them silently turns a true sentence into a false one.", id) + } + } +} + +// TestOtherDocsQuoteTheSameFigure catches the drift that actually happened. +// +// README.md and docs/README.md both quoted "148 registered / 117 serving" three +// milestones after it stopped being true, because coverage.md was the only page +// anyone thought to update and nothing checked the others. A front page is where +// the number is read most and verified least. +// +// The pattern is deliberately loose about wording and strict about the pair of +// numbers: these are prose, and pinning their phrasing would make every edit a +// test failure. +func TestOtherDocsQuoteTheSameFigure(t *testing.T) { + registered := len(plugin.DefaultRegistry.RegisteredServices()) + serving, _ := servedCounts() + + // Loose enough for both phrasings in use — "205 AWS services registered, 201 + // serving at least one operation" and "205 registered / 201 serving". + quoted := regexp.MustCompile(`(?m)(\d+)[^.\n]{0,24}?registered\b[^.\n]*?(\d+)[^.\n]{0,4}?serving`) + + for _, path := range []string{"../../README.md", "../../docs/README.md"} { + raw, err := os.ReadFile(path) + if err != nil { + t.Errorf("read %s: %v", path, err) + continue + } + + matches := quoted.FindAllStringSubmatch(string(raw), -1) + if len(matches) == 0 { + // Zero matches is a failure, not a pass. A rewording that stops + // matching would otherwise disable this check in silence, which is + // the exact way the figure went stale in the first place. + t.Errorf("%s no longer states the coverage figure in a form this gate "+ + "can read. Restore the phrasing or update the pattern deliberately.", path) + continue + } + for _, m := range matches { + gotRegistered, _ := strconv.Atoi(m[1]) + gotServing, _ := strconv.Atoi(m[2]) + if gotRegistered != registered || gotServing != serving { + t.Errorf("%s quotes %d registered / %d serving; the binary has %d / %d", + path, gotRegistered, gotServing, registered, serving) + } + } + } +} + +// demandPath is the evidence behind the published target. See docs/demand.md. +const demandPath = "../../docs/demand.md" + +// demandRow matches one row of the ranking table in docs/demand.md: +// +// | `emr-serverless` | yes | yes | yes | 3 | +var demandRow = regexp.MustCompile("(?m)^\\|\\s*`([a-z0-9-]+)`\\s*\\|[^|]*\\|[^|]*\\|[^|]*\\|\\s*(\\d+)\\s*\\|") + +// TestDemandSetIsRegistered gates the target itself, not only the count. +// +// The published target is "148 registered + the 57 services with demonstrated +// demand", and Milestone 4 met it. Nothing checked that it stays met: a service +// could be dropped from the registry and the total held constant by adding +// something else, leaving the count honest and the target quietly missed. +// +// The survey is not re-run here. It samples three external projects and its +// sample date is part of the evidence — re-sampling in CI would move the target +// silently, which is the opposite of a gate. +func TestDemandSetIsRegistered(t *testing.T) { + raw, err := os.ReadFile(demandPath) + if err != nil { + t.Fatalf("read the demand evidence: %v", err) + } + + registered := make(map[string]bool) + for _, id := range plugin.DefaultRegistry.RegisteredServices() { + registered[id] = true + } + + var demandSet, missing []string + for _, row := range demandRow.FindAllStringSubmatch(string(raw), -1) { + support, err := strconv.Atoi(row[2]) + if err != nil || support < 2 { + continue + } + name := row[1] + demandSet = append(demandSet, name) + // Demand names carry the SDK's punctuation; DevCloud service IDs have + // none. That is the only difference between the two vocabularies here. + if !registered[strings.ReplaceAll(name, "-", "")] { + missing = append(missing, name) + } + } + + const demandSetSize = 57 + if len(demandSet) != demandSetSize { + t.Errorf("docs/demand.md lists %d services with support >= 2, want %d. "+ + "The demand set defines the published target; changing it is a decision, "+ + "not a side effect.", len(demandSet), demandSetSize) + } + if len(missing) > 0 { + t.Errorf("%d services with demonstrated demand are not registered: %v. "+ + "docs/coverage.md publishes the target as met.", len(missing), missing) + } +} + +// hyphenate renders a service ID the way the docs write it: DevCloud IDs have no +// punctuation, prose uses the SDK's spelling ("rds-data" for rdsdata). +func hyphenate(id string) string { + for _, suffix := range []string{"data", "runtime", "query", "control"} { + if strings.HasSuffix(id, suffix) && len(id) > len(suffix) { + return fmt.Sprintf("%s-%s", strings.TrimSuffix(id, suffix), suffix) + } + } + return id +} diff --git a/cmd/devcloud/fidelity_test.go b/cmd/devcloud/fidelity_test.go index 0e31ce04..b1185a39 100644 --- a/cmd/devcloud/fidelity_test.go +++ b/cmd/devcloud/fidelity_test.go @@ -22,16 +22,15 @@ var validTiers = map[fidelity.Tier]bool{ // package init, so both the plugin registry and the CRUD registry hold their // full surface. Regenerate with `make codegen` when it fails. func TestFidelityManifestCoverage(t *testing.T) { - // Conservative floors, in the spirit of TestServicePluginConformance: a - // mangled generator or a dropped scan collapses these far below the real - // numbers without the fragility of asserting an exact count. - const ( - minServices = 100 - minOperations = 6000 - ) - - if len(fidelity.Services) < minServices { - t.Fatalf("manifest covers %d services, want >= %d", len(fidelity.Services), minServices) + // The counts are not floored here any more. They are asserted exactly, in + // both directions, against the figure docs/coverage.md publishes — see + // TestPublishedCoverageMatchesTheBinary and + // TestPublishedOperationTiersMatchTheManifest. The conservative floors this + // replaces (100 services, 6,000 operations) were right for catching a + // mangled generator and could not notice 205 services becoming 150, which is + // what the published claim rests on. + if len(fidelity.Services) == 0 { + t.Fatal("the fidelity manifest is empty; run `make codegen`") } operations := 0 @@ -79,9 +78,6 @@ func TestFidelityManifestCoverage(t *testing.T) { id, len(crud.RegisteredOps(id))) } } - if operations < minOperations { - t.Errorf("manifest covers %d operations, want >= %d", operations, minOperations) - } } // TestFidelityManifestCoversRegisteredServices keeps the manifest honest about diff --git a/docs/README.md b/docs/README.md index f10b5d55..de0c574e 100644 --- a/docs/README.md +++ b/docs/README.md @@ -8,7 +8,7 @@ This directory holds DevCloud's technical documentation. Use the map below to ju - **[Configuration](configuration.md)** — YAML options, env-var overrides, tier shortcuts - **[Architecture](architecture.md)** — system design, plugin model, codegen pipeline, multi-CSP vision - **[Roadmap](roadmap.md)** — phased plan toward multi-CSP support -- **[Coverage](coverage.md)** — 148 registered / 117 serving, what the count promises, and the target +- **[Coverage](coverage.md)** — 205 registered / 201 serving, what the count promises, and the target - **[Demand](demand.md)** — which unregistered services have demonstrated demand, and how that was measured - **[Services Matrix](services-matrix.md)** — per-service coverage status and boto3 pass rate diff --git a/docs/coverage.md b/docs/coverage.md index 08435ffc..4cb5df58 100644 --- a/docs/coverage.md +++ b/docs/coverage.md @@ -12,6 +12,11 @@ things: | **Registered** | The gateway routes the service. A call reaches DevCloud instead of falling through to real AWS. | **205** | | **Serving ≥1 operation** | At least one operation returns a real, store-backed answer — hand-written or served by the generic CRUD engine. | **201** | | **Registered-only** | Routed, but every operation declines with a clean AWS error. Nothing is served. | **4** | +| **Compatibility-tested** | A boto3 test exercises the service in CI and passes — either serving an operation or declining cleanly. | **199** | + +Every number on this page is asserted against the binary by +`go test ./cmd/devcloud/`. Editing one here without the code moving fails CI, and +so does the reverse. See [Reproducing these numbers](#reproducing-these-numbers). Per operation, from the [fidelity manifest](fidelity-manifest.md): @@ -53,10 +58,42 @@ Registered services by protocol: Four services are registered and serve nothing, and all four are the same case — no CRUD-shaped operation anywhere in their API: `forecastquery` (`QueryForecast`, -`QueryWhatIfForecast`), the two SageMaker Runtime variants (`InvokeEndpoint*`), -and `rds-data` (`ExecuteStatement`, `BeginTransaction`, `CommitTransaction`, +`QueryWhatIfForecast`), the two SageMaker Runtime variants `sagemaker-runtime` +and `sagemakerruntimehttp2` (`InvokeEndpoint*`), and `rds-data` +(`ExecuteStatement`, `BeginTransaction`, `CommitTransaction`, `RollbackTransaction`). No protocol change reaches them. +## Why the compatibility-tested number is 199, not 205 + +Every registered service is exercised by +`tests/compatibility/test_service_smoke.py`, which parametrises over the +generated service list rather than a hand-written one — so a service cannot be +registered and quietly go untested, which is what 31 of them were until this was +measured. Six are excluded, in two groups, and neither group is a backlog. + +**Two have no boto3 client at all.** botocore publishes 431 clients and neither +`sagemakerruntimehttp2` nor `transcribestreaming` is among them — +`sagemaker-runtime` and `transcribe` are different clients with different APIs. +No boto3 test can exist for a client that does not exist. This is a property of +the AWS SDK, not of DevCloud, and it is the ceiling on this number. + +**Four are registered and unreachable.** All four Lex clients — `lex-models`, +`lex-runtime`, `lexv2-models`, `lexv2-runtime` — sign as `lex`, and no service +is named `lex`, so the alias stays contested and routes nowhere rather than +sending one service's traffic to another. The consequence, which this page did +not state until it was measured: the "reached by its own unambiguous name" +escape below does not exist for a boto3 caller, because boto3 signs with the +contested name and offers nothing else. The four are counted in *serving ≥1 +operation*, because their operations are classified and would be served; they +are not counted here, because nothing can ask for them. + +Splitting them on the URL is what resolved `opensearch` / `elasticsearchservice` +and API Gateway v1 / v2, and it does not work here: `/bots` is the first path +segment for three of the four. A correct split needs full path matching across +all four, which is routing work rather than coverage work. +`test_lex_services_are_unreachable_from_boto3` pins the current state, so +fixing the routing fails that test and moves this number up with it. + Being engine-servable is not the same as being served. Thirteen of the fifteen `query` services and three of the four `rest-xml` ones have hand-written providers that answer their own unknown operations, so they never enter the @@ -273,10 +310,22 @@ store, not by how many services are registered. ```bash make codegen # regenerate the manifest from the models make stats # registered services and hand-written operations -go test ./cmd/devcloud/ # asserts the manifest against the live registry +go test ./cmd/devcloud/ # asserts every number on this page against the binary +make test-compat # the compatibility-tested number, over all 205 services ``` -The three service numbers come from `internal/generated/fidelity/manifest_gen.go` -and nothing else, so they cannot drift from what the binary actually serves — -`TestFidelityManifestCoverage` and `TestFidelityManifestCoversCRUDRegistry` fail -if they do. +The service and operation numbers come from +`internal/generated/fidelity/manifest_gen.go` and nothing else, so they cannot +drift from what the binary actually serves — `TestFidelityManifestCoverage` and +`TestFidelityManifestCoversCRUDRegistry` fail if they do. + +They cannot drift from *this page* either. +`TestPublishedCoverageMatchesTheBinary` and +`TestPublishedOperationTiersMatchTheManifest` read the tables above and compare +each figure to the live registry and manifest, in both directions: a service +removed without editing the page fails, and a figure edited here without the +code moving fails identically. `TestRegisteredOnlyServicesAreNamedInTheDocs` +does the same for the depth claim, so a service that starts serving nothing +cannot join that set without being named. `TestDemandSetIsRegistered` checks the +target itself — all 57 services in [demand.md](demand.md) are still registered, +so the count cannot be held steady by swapping one out for something else. diff --git a/docs/demand.md b/docs/demand.md index 3c87ff88..344e7ebb 100644 --- a/docs/demand.md +++ b/docs/demand.md @@ -53,10 +53,12 @@ Ordered by support count, then name. This is the order Milestone 4 worked in, so stopping at any point would have stopped on the best surface available. **All 57 services with support ≥ 2 are now registered** — the rows down to and -including `workspaces-web`. 54 of them serve at least one operation; the three -that do not (`elastic-load-balancing`, `rds-data`, `s3-control`) are named with -their reasons in [coverage.md](coverage.md). The rows below them, support 1 and -support 0, are the 226 services that remain explicitly not targeted. +including `workspaces-web`, and `TestDemandSetIsRegistered` fails if any of them +stops being. 56 of them serve at least one operation; the one that does not +(`rds-data`) is named with its reason in [coverage.md](coverage.md). +`elastic-load-balancing` and `s3-control` were the other two until Milestone 5 +served both. The rows below them, support 1 and support 0, are the 226 services +that remain explicitly not targeted. | Service | moto | LocalStack | terraform-provider-aws | Support | |---|---|---|---|---| diff --git a/internal/codegen/gen_compat_manifest.go b/internal/codegen/gen_compat_manifest.go new file mode 100644 index 00000000..d001c779 --- /dev/null +++ b/internal/codegen/gen_compat_manifest.go @@ -0,0 +1,68 @@ +// SPDX-License-Identifier: Apache-2.0 + +// internal/codegen/gen_compat_manifest.go +package codegen + +import "encoding/json" + +// CompatService is one service's entry in the compatibility suite's manifest. +type CompatService struct { + // Protocol is the service's wire protocol, reported so a failing case names + // it rather than making a reader look it up. + Protocol string `json:"protocol"` + // ServedOps are the operations the fidelity manifest says actually answer — + // hand-verified or auto-crud, never unimplemented. The suite picks its probe + // from this set, so it never asks a service for an operation the manifest + // has already declared unserved and then reports the honest failure as a + // broken service. + // + // Empty is meaningful: it is what makes a service a decline case, and the + // "never a fabricated success" guarantee applies to exactly those. + ServedOps []string `json:"servedOps"` +} + +// BuildCompatManifest projects the fidelity data down to what the boto3 +// compatibility suite needs to parametrize itself. +// +// The suite used to carry two hand-written service lists, which is why a service +// could be registered, counted in the published coverage figure, and exercised +// by no test at all: adding it to internal/services was one step and adding it +// to the list was another, and nothing failed when only the first happened. +// Deriving the list here means the second step no longer exists. +// +// Registered, not served, is the membership rule. A service that answers +// nothing still appears, with an empty ServedOps — it is the one whose "declines +// with a clean AWS error rather than a fabricated success" guarantee most needs +// a test, and it is the case docs/coverage.md calls absolute. +func BuildCompatManifest(data FidelityData) map[string]CompatService { + manifest := make(map[string]CompatService, len(data.Services)) + for _, svc := range data.Services { + // Non-nil so the JSON is [] rather than null: Python distinguishes them, + // and "no served operations" is a real state rather than a missing field. + served := make([]string, 0, len(svc.Ops)) + for _, op := range svc.Ops { + if op.TierConst == "Unimplemented" { + continue + } + served = append(served, op.Name) + } + manifest[svc.ServiceID] = CompatService{ + Protocol: svc.Protocol, + ServedOps: served, + } + } + return manifest +} + +// RenderCompatManifest marshals the manifest for the compatibility suite. +// +// encoding/json sorts map keys and FidelityData arrives with its operations +// already sorted, so the output is byte-stable across runs — which is what the +// codegen-drift CI job requires of everything under internal/generated. +func RenderCompatManifest(manifest map[string]CompatService) ([]byte, error) { + out, err := json.MarshalIndent(manifest, "", " ") + if err != nil { + return nil, err + } + return append(out, '\n'), nil +} diff --git a/internal/codegen/gen_compat_manifest_test.go b/internal/codegen/gen_compat_manifest_test.go new file mode 100644 index 00000000..a5ea29e9 --- /dev/null +++ b/internal/codegen/gen_compat_manifest_test.go @@ -0,0 +1,80 @@ +// SPDX-License-Identifier: Apache-2.0 + +// internal/codegen/gen_compat_manifest_test.go +package codegen + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// fidelityFixture builds the manifest input for a two-service fleet: one that +// serves something, one that serves nothing at all. +func fidelityFixture() FidelityData { + modelOps := map[string][]string{ + "served": {"CreateThing", "ListThings", "RunSomething"}, + "declines": {"ExecuteStatement"}, + } + providers := map[string]ProviderScan{ + "served": {Operations: []string{"CreateThing"}, EngineWired: true}, + "declines": {EngineWired: true}, + } + autoCRUD := []CRUDServiceData{ + {ServiceID: "served", Ops: []crudOpData{{Op: "ListThings", Verb: "List"}}}, + } + protocols := map[string]string{"served": "json-1.1", "declines": "rest-json"} + + return BuildFidelityData(modelOps, protocols, providers, autoCRUD) +} + +// TestBuildCompatManifestListsEveryRegisteredService is the property the +// coverage gate rests on: the compatibility suite parametrizes over this file, +// so a service missing from it is a service nothing tests. A service that serves +// nothing must still appear — it is the one whose "declines cleanly" guarantee +// most needs a test. +func TestBuildCompatManifestListsEveryRegisteredService(t *testing.T) { + manifest := BuildCompatManifest(fidelityFixture()) + + require.Len(t, manifest, 2) + assert.Contains(t, manifest, "served") + assert.Contains(t, manifest, "declines", + "a service that serves nothing is still tested, for the decline guarantee") +} + +// TestBuildCompatManifestServedOpsExcludeUnimplemented keeps the suite from +// asking a service for an operation the manifest already says is unimplemented. +// Such a call fails, correctly, and would read as the service being broken. +func TestBuildCompatManifestServedOpsExcludeUnimplemented(t *testing.T) { + manifest := BuildCompatManifest(fidelityFixture()) + + assert.Equal(t, []string{"CreateThing", "ListThings"}, manifest["served"].ServedOps, + "hand-verified and auto-crud are served; RunSomething is unimplemented and must not appear") + assert.Empty(t, manifest["declines"].ServedOps, + "a service with no served operation reports none, which is what makes it a decline case") +} + +// TestBuildCompatManifestCarriesProtocol publishes why a service serves what it +// does. docs/coverage.md splits the fleet by protocol, and the compat suite +// reports it on failure so a broken service names its own protocol. +func TestBuildCompatManifestCarriesProtocol(t *testing.T) { + manifest := BuildCompatManifest(fidelityFixture()) + + assert.Equal(t, "json-1.1", manifest["served"].Protocol) + assert.Equal(t, "rest-json", manifest["declines"].Protocol) +} + +// TestRenderCompatManifestIsStable keeps `make codegen` idempotent. The +// codegen-drift CI job diffs the regenerated tree, so unstable ordering here +// would fail every unrelated pull request. +func TestRenderCompatManifestIsStable(t *testing.T) { + first, err := RenderCompatManifest(BuildCompatManifest(fidelityFixture())) + require.NoError(t, err) + second, err := RenderCompatManifest(BuildCompatManifest(fidelityFixture())) + require.NoError(t, err) + + assert.Equal(t, string(first), string(second)) + assert.Contains(t, string(first), `"protocol": "json-1.1"`, + "the file is read by Python, so it is indented JSON rather than a Go literal") +} diff --git a/internal/generated/compat/services.json b/internal/generated/compat/services.json new file mode 100644 index 00000000..8c92af42 --- /dev/null +++ b/internal/generated/compat/services.json @@ -0,0 +1,10489 @@ +{ + "account": { + "protocol": "", + "servedOps": [ + "AcceptPrimaryEmailUpdate", + "DeleteAlternateContact", + "DeleteContactInformation", + "DisableRegion", + "EnableRegion", + "GetAccount", + "GetAlternateContact", + "GetContactInformation", + "GetPrimaryEmail", + "GetRegionOptStatus", + "ListAccountManagedUsers", + "ListRegions", + "PutAlternateContact", + "PutContactInformation", + "StartPrimaryEmailUpdate" + ] + }, + "acm": { + "protocol": "json-1.1", + "servedOps": [ + "AddTagsToCertificate", + "CancelCertificateIssuance", + "CreatePermission", + "DeleteCertificate", + "DeletePermission", + "DescribeCertificate", + "DescribeCertificateAuthority", + "DescribeCertificateEvents", + "DescribeCertificateValidation", + "ExportCertificate", + "GetAccountConfiguration", + "GetCSR", + "GetCertificate", + "GetCertificateAuthorityCertificate", + "GetCertificateAuthorityCsr", + "GetCertificateChain", + "GetCertificateRenewal", + "GetIssuerCertificate", + "ImportCertificate", + "ListCertificateAuthorities", + "ListCertificateTransparency", + "ListCertificates", + "ListIssuers", + "ListPermissions", + "ListRenewalEvents", + "ListTagsForCertificate", + "PutAccountConfiguration", + "PutConfigurationRecorder", + "RemoveTagsFromCertificate", + "RenewCertificate", + "RequestCertificate", + "ResendValidationEmail", + "RevokeCertificate", + "StartCertificateIssuance", + "UpdateCertificate", + "UpdateCertificateOptions", + "WaitForValidation" + ] + }, + "acmpca": { + "protocol": "json-1.1", + "servedOps": [ + "CreateCertificateAuthority", + "CreateCertificateAuthorityAuditReport", + "CreatePermission", + "DeleteCertificateAuthority", + "DeletePermission", + "DeletePolicy", + "DescribeCertificateAuthority", + "DescribeCertificateAuthorityAuditReport", + "GetCertificate", + "GetCertificateAuthorityCertificate", + "GetCertificateAuthorityCsr", + "GetPolicy", + "ImportCertificateAuthorityCertificate", + "IssueCertificate", + "ListCertificateAuthorities", + "ListPermissions", + "ListTags", + "PutPolicy", + "RestoreCertificateAuthority", + "RevokeCertificate", + "TagCertificateAuthority", + "UntagCertificateAuthority", + "UpdateCertificateAuthority" + ] + }, + "amp": { + "protocol": "rest-json", + "servedOps": [ + "CreateAlertManagerDefinition", + "CreateAnomalyDetector", + "CreateLoggingConfiguration", + "CreateQueryLoggingConfiguration", + "CreateRuleGroupsNamespace", + "CreateScraper", + "CreateWorkspace", + "DeleteAlertManagerDefinition", + "DeleteAnomalyDetector", + "DeleteLoggingConfiguration", + "DeleteQueryLoggingConfiguration", + "DeleteResourcePolicy", + "DeleteRuleGroupsNamespace", + "DeleteScraper", + "DeleteScraperLoggingConfiguration", + "DeleteWorkspace", + "DescribeAlertManagerDefinition", + "DescribeAnomalyDetector", + "DescribeLoggingConfiguration", + "DescribeQueryLoggingConfiguration", + "DescribeResourcePolicy", + "DescribeRuleGroupsNamespace", + "DescribeScraper", + "DescribeScraperLoggingConfiguration", + "DescribeWorkspace", + "DescribeWorkspaceConfiguration", + "GetDefaultScraperConfiguration", + "ListAnomalyDetectors", + "ListRuleGroupsNamespaces", + "ListScrapers", + "ListTagsForResource", + "ListWorkspaces", + "PutAlertManagerDefinition", + "PutAnomalyDetector", + "PutResourcePolicy", + "PutRuleGroupsNamespace", + "TagResource", + "UntagResource", + "UpdateLoggingConfiguration", + "UpdateQueryLoggingConfiguration", + "UpdateScraper", + "UpdateScraperLoggingConfiguration", + "UpdateWorkspaceAlias", + "UpdateWorkspaceConfiguration" + ] + }, + "amplify": { + "protocol": "rest-json", + "servedOps": [ + "CreateApp", + "CreateBackendEnvironment", + "CreateBranch", + "CreateDeployment", + "CreateDomainAssociation", + "CreateWebhook", + "DeleteApp", + "DeleteBackendEnvironment", + "DeleteBranch", + "DeleteDomainAssociation", + "DeleteJob", + "DeleteWebhook", + "GenerateAccessLogs", + "GetApp", + "GetArtifactUrl", + "GetBackendEnvironment", + "GetBranch", + "GetDomainAssociation", + "GetJob", + "GetWebhook", + "ListApps", + "ListArtifacts", + "ListBackendEnvironments", + "ListBranches", + "ListDomainAssociations", + "ListJobs", + "ListTagsForResource", + "ListWebhooks", + "StartDeployment", + "StartJob", + "StopJob", + "TagResource", + "UntagResource", + "UpdateApp", + "UpdateBranch", + "UpdateDomainAssociation", + "UpdateWebhook" + ] + }, + "apigateway": { + "protocol": "rest-json", + "servedOps": [ + "CreateApiKey", + "CreateAuthorizer", + "CreateBasePathMapping", + "CreateDeployment", + "CreateDocumentationPart", + "CreateDocumentationVersion", + "CreateDomainName", + "CreateDomainNameAccessAssociation", + "CreateModel", + "CreateRequestValidator", + "CreateResource", + "CreateRestApi", + "CreateStage", + "CreateUsagePlan", + "CreateUsagePlanKey", + "CreateVpcLink", + "DeleteApiKey", + "DeleteAuthorizer", + "DeleteBasePathMapping", + "DeleteClientCertificate", + "DeleteDeployment", + "DeleteDocumentationPart", + "DeleteDocumentationVersion", + "DeleteDomainName", + "DeleteDomainNameAccessAssociation", + "DeleteGatewayResponse", + "DeleteIntegration", + "DeleteIntegrationResponse", + "DeleteMethod", + "DeleteMethodResponse", + "DeleteModel", + "DeleteRequestValidator", + "DeleteResource", + "DeleteRestApi", + "DeleteStage", + "DeleteUsagePlan", + "DeleteUsagePlanKey", + "DeleteVpcLink", + "GetAccount", + "GetApiKey", + "GetApiKeys", + "GetAuthorizer", + "GetAuthorizers", + "GetBasePathMapping", + "GetBasePathMappings", + "GetClientCertificate", + "GetClientCertificates", + "GetDeployment", + "GetDeployments", + "GetDocumentationPart", + "GetDocumentationParts", + "GetDocumentationVersion", + "GetDocumentationVersions", + "GetDomainName", + "GetDomainNameAccessAssociations", + "GetDomainNames", + "GetExport", + "GetGatewayResponse", + "GetGatewayResponses", + "GetIntegration", + "GetIntegrationResponse", + "GetMethod", + "GetMethodResponse", + "GetModel", + "GetModelTemplate", + "GetModels", + "GetRequestValidator", + "GetRequestValidators", + "GetResource", + "GetResources", + "GetRestApi", + "GetRestApis", + "GetSdk", + "GetSdkType", + "GetSdkTypes", + "GetStage", + "GetStages", + "GetTags", + "GetUsage", + "GetUsagePlan", + "GetUsagePlanKey", + "GetUsagePlanKeys", + "GetUsagePlans", + "GetVpcLink", + "GetVpcLinks", + "PutGatewayResponse", + "PutIntegration", + "PutIntegrationResponse", + "PutMethod", + "PutMethodResponse", + "PutRestApi", + "TagResource", + "UntagResource", + "UpdateAccount", + "UpdateApiKey", + "UpdateAuthorizer", + "UpdateBasePathMapping", + "UpdateClientCertificate", + "UpdateDeployment", + "UpdateDocumentationPart", + "UpdateDocumentationVersion", + "UpdateDomainName", + "UpdateGatewayResponse", + "UpdateIntegration", + "UpdateIntegrationResponse", + "UpdateMethod", + "UpdateMethodResponse", + "UpdateModel", + "UpdateRequestValidator", + "UpdateResource", + "UpdateRestApi", + "UpdateStage", + "UpdateUsage", + "UpdateUsagePlan", + "UpdateVpcLink" + ] + }, + "apigatewaymanagementapi": { + "protocol": "rest-json", + "servedOps": [ + "DeleteConnection", + "GetConnection" + ] + }, + "apigatewayv2": { + "protocol": "rest-json", + "servedOps": [ + "CreateApi", + "CreateApiMapping", + "CreateAuthorizer", + "CreateDeployment", + "CreateDomainName", + "CreateIntegration", + "CreateIntegrationResponse", + "CreateModel", + "CreateRoute", + "CreateRouteResponse", + "CreateStage", + "CreateVpcLink", + "DeleteAccessLogSettings", + "DeleteApi", + "DeleteApiMapping", + "DeleteAuthorizer", + "DeleteCorsConfiguration", + "DeleteDeployment", + "DeleteDomainName", + "DeleteIntegration", + "DeleteIntegrationResponse", + "DeleteModel", + "DeleteRoute", + "DeleteRouteRequestParameter", + "DeleteRouteResponse", + "DeleteRouteSettings", + "DeleteStage", + "DeleteVpcLink", + "ExportApi", + "GetApi", + "GetApiMapping", + "GetApiMappings", + "GetApis", + "GetAuthorizer", + "GetAuthorizers", + "GetDeployment", + "GetDeployments", + "GetDomainName", + "GetDomainNames", + "GetIntegration", + "GetIntegrationResponse", + "GetIntegrationResponses", + "GetIntegrations", + "GetModel", + "GetModelTemplate", + "GetModels", + "GetRoute", + "GetRouteResponse", + "GetRouteResponses", + "GetRoutes", + "GetStage", + "GetStages", + "GetTags", + "GetVpcLink", + "GetVpcLinks", + "ImportApi", + "ReimportApi", + "ResetAuthorizersCache", + "TagResource", + "UntagResource", + "UpdateApi", + "UpdateApiMapping", + "UpdateAuthorizer", + "UpdateDeployment", + "UpdateDomainName", + "UpdateIntegration", + "UpdateIntegrationResponse", + "UpdateModel", + "UpdateRoute", + "UpdateStage", + "UpdateVpcLink" + ] + }, + "appconfig": { + "protocol": "rest-json", + "servedOps": [ + "CreateApplication", + "CreateConfigurationProfile", + "CreateDeploymentStrategy", + "CreateEnvironment", + "CreateExtension", + "CreateExtensionAssociation", + "CreateHostedConfigurationVersion", + "DeleteApplication", + "DeleteConfigurationProfile", + "DeleteDeploymentStrategy", + "DeleteEnvironment", + "DeleteExtension", + "DeleteExtensionAssociation", + "DeleteHostedConfigurationVersion", + "GetAccountSettings", + "GetApplication", + "GetConfiguration", + "GetConfigurationProfile", + "GetDeployment", + "GetDeploymentStrategy", + "GetEnvironment", + "GetExtension", + "GetExtensionAssociation", + "GetHostedConfigurationVersion", + "ListApplications", + "ListConfigurationProfiles", + "ListDeploymentStrategies", + "ListDeployments", + "ListEnvironments", + "ListExtensionAssociations", + "ListExtensions", + "ListHostedConfigurationVersions", + "ListTagsForResource", + "StartDeployment", + "StopDeployment", + "TagResource", + "UntagResource", + "UpdateAccountSettings", + "UpdateApplication", + "UpdateConfigurationProfile", + "UpdateDeploymentStrategy", + "UpdateEnvironment", + "UpdateExtension", + "UpdateExtensionAssociation", + "ValidateConfiguration" + ] + }, + "applicationautoscaling": { + "protocol": "json-1.1", + "servedOps": [ + "BatchDeleteScalingPolicy", + "BatchDeleteScheduledAction", + "BatchDeregisterScalableTarget", + "BatchPutScalingPolicy", + "BatchPutScheduledAction", + "BatchRegisterScalableTarget", + "DeleteCustomizedMetricStatistics", + "DeleteScalingPolicy", + "DeleteScheduledAction", + "DeleteTargetTrackingScalingPolicy", + "DeregisterScalableTarget", + "DescribeAccountLimits", + "DescribeCustomizedMetricStatistics", + "DescribePredictiveScalingForecast", + "DescribeResourceActions", + "DescribeScalableTargets", + "DescribeScalingActivities", + "DescribeScalingPolicies", + "DescribeScheduledActions", + "DescribeServiceQuotas", + "DescribeStatistics", + "GetMetricStatistics", + "GetPredictiveScalingForecast", + "GetScalingHealth", + "GetScalingStatus", + "GetTargetTrackingScalingPolicy", + "ListScalableTargetsByService", + "ListTagsForResource", + "PutCustomizedMetricStatistics", + "PutPredictiveScalingForecast", + "PutScalingPolicy", + "PutScheduledAction", + "PutTargetTrackingScalingPolicy", + "RecordScalingActivity", + "RegisterScalableTarget", + "TagResource", + "UntagResource", + "UpdateScalableTarget", + "UpdateScalingPolicy", + "UpdateScheduledAction" + ] + }, + "appmesh": { + "protocol": "rest-json", + "servedOps": [ + "CreateGatewayRoute", + "CreateMesh", + "CreateRoute", + "CreateVirtualGateway", + "CreateVirtualNode", + "CreateVirtualRouter", + "CreateVirtualService", + "DeleteGatewayRoute", + "DeleteMesh", + "DeleteRoute", + "DeleteVirtualGateway", + "DeleteVirtualNode", + "DeleteVirtualRouter", + "DeleteVirtualService", + "DescribeGatewayRoute", + "DescribeMesh", + "DescribeRoute", + "DescribeVirtualGateway", + "DescribeVirtualNode", + "DescribeVirtualRouter", + "DescribeVirtualService", + "ListGatewayRoutes", + "ListMeshes", + "ListRoutes", + "ListTagsForResource", + "ListVirtualGateways", + "ListVirtualNodes", + "ListVirtualRouters", + "ListVirtualServices", + "TagResource", + "UntagResource", + "UpdateGatewayRoute", + "UpdateMesh", + "UpdateRoute", + "UpdateVirtualGateway", + "UpdateVirtualNode", + "UpdateVirtualRouter", + "UpdateVirtualService" + ] + }, + "appsync": { + "protocol": "rest-json", + "servedOps": [ + "AssociateApi", + "AssociateMergedGraphqlApi", + "AssociateSourceGraphqlApi", + "CreateApi", + "CreateApiCache", + "CreateApiKey", + "CreateChannelNamespace", + "CreateDataSource", + "CreateDomainName", + "CreateFunction", + "CreateGraphqlApi", + "CreateMergedApiAssociation", + "CreateResolver", + "CreateType", + "DeleteApi", + "DeleteApiCache", + "DeleteApiKey", + "DeleteChannelNamespace", + "DeleteDataSource", + "DeleteDomainName", + "DeleteFunction", + "DeleteGraphqlApi", + "DeleteMergedApiAssociation", + "DeleteResolver", + "DeleteType", + "DisassociateApi", + "DisassociateMergedGraphqlApi", + "DisassociateSourceGraphqlApi", + "EvaluateCode", + "EvaluateMappingTemplate", + "FlushApiCache", + "GetApi", + "GetApiAssociation", + "GetApiCache", + "GetChannelNamespace", + "GetDataSource", + "GetDataSourceIntrospection", + "GetDomainName", + "GetFunction", + "GetGraphqlApi", + "GetGraphqlApiEnvironmentVariables", + "GetIntrospectionSchema", + "GetResolver", + "GetSchemaCreationStatus", + "GetSchemaError", + "GetSourceApiAssociation", + "GetType", + "ListApiKeys", + "ListApis", + "ListChannelNamespaces", + "ListDataSources", + "ListDomainNames", + "ListFunctions", + "ListGraphqlApis", + "ListMergedApiAssociations", + "ListResolvers", + "ListResolversByFunction", + "ListSourceApiAssociations", + "ListTagsForResource", + "ListTypes", + "PutGraphqlApiEnvironmentVariables", + "StartDataSourceIntrospection", + "StartSchemaCreation", + "StartSchemaMerge", + "TagResource", + "UntagResource", + "UpdateApi", + "UpdateApiCache", + "UpdateApiKey", + "UpdateChannelNamespace", + "UpdateDataSource", + "UpdateDomainName", + "UpdateFunction", + "UpdateGraphqlApi", + "UpdateResolver", + "UpdateSourceApiAssociation", + "UpdateType" + ] + }, + "athena": { + "protocol": "json-1.1", + "servedOps": [ + "BatchGetNamedQuery", + "BatchGetPreparedStatement", + "BatchGetQueryExecution", + "CancelCapacityReservation", + "CreateCapacityReservation", + "CreateDataCatalog", + "CreateNamedQuery", + "CreateNotebook", + "CreatePreparedStatement", + "CreatePresignedNotebookUrl", + "CreateWorkGroup", + "DeleteCapacityReservation", + "DeleteDataCatalog", + "DeleteNamedQuery", + "DeleteNotebook", + "DeletePreparedStatement", + "DeleteWorkGroup", + "ExportNotebook", + "GetCalculationExecution", + "GetCalculationExecutionCode", + "GetCalculationExecutionStatus", + "GetCapacityAssignmentConfiguration", + "GetCapacityReservation", + "GetDataCatalog", + "GetDatabase", + "GetNamedQuery", + "GetNotebookMetadata", + "GetPreparedStatement", + "GetQueryExecution", + "GetQueryResults", + "GetQueryRuntimeStatistics", + "GetResourceDashboard", + "GetSession", + "GetSessionEndpoint", + "GetSessionStatus", + "GetTableMetadata", + "GetWorkGroup", + "ImportNotebook", + "ListApplicationDPUSizes", + "ListCalculationExecutions", + "ListCapacityReservations", + "ListDataCatalogs", + "ListDatabases", + "ListEngineVersions", + "ListExecutors", + "ListNamedQueries", + "ListNotebookMetadata", + "ListNotebookSessions", + "ListPreparedStatements", + "ListQueryExecutions", + "ListSessions", + "ListTableMetadata", + "ListTagsForResource", + "ListWorkGroups", + "PutCapacityAssignmentConfiguration", + "StartCalculationExecution", + "StartQueryExecution", + "StartSession", + "StopCalculationExecution", + "StopQueryExecution", + "TagResource", + "TerminateSession", + "UntagResource", + "UpdateCapacityReservation", + "UpdateDataCatalog", + "UpdateNamedQuery", + "UpdateNotebook", + "UpdateNotebookMetadata", + "UpdatePreparedStatement", + "UpdateWorkGroup" + ] + }, + "autoscaling": { + "protocol": "query", + "servedOps": [ + "AttachInstances", + "AttachLoadBalancerTargetGroups", + "AttachLoadBalancers", + "AttachTrafficSources", + "BatchDeleteScheduledAction", + "BatchPutScheduledUpdateGroupAction", + "CancelInstanceRefresh", + "CompleteLifecycleAction", + "CreateAutoScalingGroup", + "CreateLaunchConfiguration", + "CreateOrUpdateTags", + "DeleteAutoScalingGroup", + "DeleteLaunchConfiguration", + "DeleteLifecycleHook", + "DeletePolicy", + "DeleteScheduledAction", + "DeleteTags", + "DescribeAccountLimits", + "DescribeAutoScalingGroups", + "DescribeAutoScalingInstances", + "DescribeInstanceRefreshes", + "DescribeLaunchConfigurations", + "DescribeLifecycleHooks", + "DescribePolicies", + "DescribeScheduledActions", + "DescribeTags", + "DetachInstances", + "DetachLoadBalancerTargetGroups", + "DetachLoadBalancers", + "DetachTrafficSources", + "DisableMetricsCollection", + "EnableMetricsCollection", + "EnterStandby", + "ExecutePolicy", + "ExitStandby", + "PutLifecycleHook", + "PutScalingPolicy", + "PutScheduledUpdateGroupAction", + "RecordLifecycleActionHeartbeat", + "ResumeProcesses", + "RollbackInstanceRefresh", + "SetDesiredCapacity", + "SetInstanceHealth", + "SetInstanceProtection", + "StartInstanceRefresh", + "SuspendProcesses", + "TerminateInstanceInAutoScalingGroup", + "UpdateAutoScalingGroup" + ] + }, + "backup": { + "protocol": "rest-json", + "servedOps": [ + "CreateBackupPlan", + "CreateBackupSelection", + "CreateBackupVault", + "CreateFramework", + "CreateReportPlan", + "CreateRestoreTestingPlan", + "CreateRestoreTestingSelection", + "DeleteBackupPlan", + "DeleteBackupSelection", + "DeleteBackupVault", + "DeleteBackupVaultAccessPolicy", + "DeleteBackupVaultLockConfiguration", + "DeleteBackupVaultNotifications", + "DeleteFramework", + "DeleteRecoveryPoint", + "DeleteReportPlan", + "DeleteRestoreTestingPlan", + "DeleteRestoreTestingSelection", + "DescribeBackupJob", + "DescribeBackupVault", + "DescribeFramework", + "DescribeGlobalSettings", + "DescribeProtectedResource", + "DescribeRecoveryPoint", + "DescribeRegionSettings", + "DescribeReportJob", + "DescribeReportPlan", + "DescribeRestoreJob", + "ExportBackupPlanTemplate", + "GetBackupPlan", + "GetBackupPlanFromJSON", + "GetBackupPlanFromTemplate", + "GetBackupSelection", + "GetBackupVaultAccessPolicy", + "GetBackupVaultNotifications", + "GetRecoveryPointIndexDetails", + "GetRecoveryPointRestoreMetadata", + "GetRestoreJobMetadata", + "GetRestoreTestingInferredMetadata", + "GetRestoreTestingPlan", + "GetRestoreTestingSelection", + "GetSupportedResourceTypes", + "ListBackupJobSummaries", + "ListBackupJobs", + "ListBackupPlanTemplates", + "ListBackupPlanVersions", + "ListBackupPlans", + "ListBackupSelections", + "ListBackupVaults", + "ListFrameworks", + "ListIndexedRecoveryPoints", + "ListProtectedResources", + "ListProtectedResourcesByBackupVault", + "ListRecoveryPointsByBackupVault", + "ListRecoveryPointsByResource", + "ListReportJobs", + "ListReportPlans", + "ListRestoreJobSummaries", + "ListRestoreJobs", + "ListRestoreJobsByProtectedResource", + "ListRestoreTestingPlans", + "ListRestoreTestingSelections", + "ListTags", + "PutBackupVaultAccessPolicy", + "PutBackupVaultLockConfiguration", + "PutBackupVaultNotifications", + "PutRestoreValidationResult", + "StartBackupJob", + "StartReportJob", + "StartRestoreJob", + "StopBackupJob", + "TagResource", + "UntagResource", + "UpdateBackupPlan", + "UpdateFramework", + "UpdateGlobalSettings", + "UpdateRecoveryPointIndexSettings", + "UpdateRecoveryPointLifecycle", + "UpdateRegionSettings", + "UpdateReportPlan", + "UpdateRestoreTestingPlan", + "UpdateRestoreTestingSelection" + ] + }, + "batch": { + "protocol": "rest-json", + "servedOps": [ + "CancelJob", + "CreateComputeEnvironment", + "CreateConsumableResource", + "CreateJobQueue", + "CreateQuotaShare", + "CreateSchedulingPolicy", + "CreateServiceEnvironment", + "DeleteComputeEnvironment", + "DeleteConsumableResource", + "DeleteJobQueue", + "DeleteQuotaShare", + "DeleteSchedulingPolicy", + "DeleteServiceEnvironment", + "DeregisterJobDefinition", + "DescribeComputeEnvironments", + "DescribeConsumableResource", + "DescribeJobDefinitions", + "DescribeJobQueues", + "DescribeJobs", + "DescribeQuotaShare", + "DescribeSchedulingPolicies", + "DescribeServiceEnvironments", + "DescribeServiceJob", + "GetJobQueueSnapshot", + "ListConsumableResources", + "ListJobs", + "ListJobsByConsumableResource", + "ListQuotaShares", + "ListSchedulingPolicies", + "ListServiceJobs", + "ListTagsForResource", + "RegisterJobDefinition", + "SubmitJob", + "SubmitServiceJob", + "TagResource", + "TerminateJob", + "TerminateServiceJob", + "UntagResource", + "UpdateComputeEnvironment", + "UpdateConsumableResource", + "UpdateJobQueue", + "UpdateQuotaShare", + "UpdateSchedulingPolicy", + "UpdateServiceEnvironment", + "UpdateServiceJob" + ] + }, + "bedrock": { + "protocol": "rest-json", + "servedOps": [ + "CreateGuardrail", + "CreateModelCustomizationJob", + "DeleteCustomModel", + "DeleteGuardrail", + "GetCustomModel", + "GetFoundationModel", + "GetGuardrail", + "GetModelCustomizationJob", + "InvokeModel", + "InvokeModelWithResponseStream", + "ListCustomModels", + "ListFoundationModels", + "ListGuardrails", + "ListModelCustomizationJobs", + "ListTagsForResource", + "StopModelCustomizationJob", + "TagResource", + "UntagResource", + "UpdateGuardrail" + ] + }, + "bedrockagent": { + "protocol": "rest-json", + "servedOps": [ + "CreateAgent", + "CreateAgentActionGroup", + "CreateAgentAlias", + "CreateDataSource", + "CreateFlow", + "CreateFlowAlias", + "CreateFlowVersion", + "CreateKnowledgeBase", + "CreatePrompt", + "CreatePromptVersion", + "DeleteAgent", + "DeleteAgentActionGroup", + "DeleteAgentAlias", + "DeleteAgentVersion", + "DeleteDataSource", + "DeleteFlow", + "DeleteFlowAlias", + "DeleteFlowVersion", + "DeleteKnowledgeBase", + "DeleteKnowledgeBaseDocuments", + "DeletePrompt", + "DeleteResourcePolicy", + "GetAgent", + "GetAgentActionGroup", + "GetAgentAlias", + "GetAgentCollaborator", + "GetAgentKnowledgeBase", + "GetAgentVersion", + "GetDataSource", + "GetFlow", + "GetFlowAlias", + "GetFlowVersion", + "GetIngestionJob", + "GetKnowledgeBase", + "GetKnowledgeBaseDocuments", + "GetPrompt", + "GetResourcePolicy", + "ListAgentActionGroups", + "ListAgentAliases", + "ListAgentCollaborators", + "ListAgentKnowledgeBases", + "ListAgentVersions", + "ListAgents", + "ListDataSources", + "ListFlowAliases", + "ListFlowVersions", + "ListFlows", + "ListIngestionJobs", + "ListKnowledgeBaseDocuments", + "ListKnowledgeBases", + "ListPrompts", + "ListTagsForResource", + "PutResourcePolicy", + "TagResource", + "UntagResource", + "UpdateAgent", + "UpdateAgentActionGroup", + "UpdateAgentAlias", + "UpdateAgentCollaborator", + "UpdateAgentKnowledgeBase", + "UpdateDataSource", + "UpdateFlow", + "UpdateFlowAlias", + "UpdateKnowledgeBase", + "UpdatePrompt" + ] + }, + "bedrockagentcore": { + "protocol": "rest-json", + "servedOps": [ + "CreateABTest", + "CreateEvent", + "CreatePaymentInstrument", + "CreatePaymentSession", + "DeleteABTest", + "DeleteBatchEvaluation", + "DeleteCapacityProviderSession", + "DeleteEvent", + "DeleteMemoryRecord", + "DeletePaymentInstrument", + "DeletePaymentSession", + "DeleteRecommendation", + "GetABTest", + "GetAgentCard", + "GetBatchEvaluation", + "GetBrowserSession", + "GetCodeInterpreterSession", + "GetEvent", + "GetMemoryRecord", + "GetPaymentInstrument", + "GetPaymentInstrumentBalance", + "GetPaymentSession", + "GetRecommendation", + "GetResourceApiKey", + "GetResourceOauth2Token", + "GetResourcePaymentToken", + "GetWorkloadAccessToken", + "GetWorkloadAccessTokenForJWT", + "GetWorkloadAccessTokenForUserId", + "ListABTests", + "ListActors", + "ListBatchEvaluations", + "ListBrowserSessions", + "ListCodeInterpreterSessions", + "ListEvents", + "ListMemoryExtractionJobs", + "ListMemoryRecords", + "ListPaymentInstruments", + "ListPaymentSessions", + "ListRecommendations", + "ListSessions", + "UpdateABTest", + "UpdateBrowserStream" + ] + }, + "bedrockagentcorecontrol": { + "protocol": "rest-json", + "servedOps": [ + "CreateAgentRuntime", + "CreateAgentRuntimeEndpoint", + "CreateApiKeyCredentialProvider", + "CreateBrowser", + "CreateBrowserProfile", + "CreateCapacityProvider", + "CreateCodeInterpreter", + "CreateConfigurationBundle", + "CreateConsentPortal", + "CreateDataset", + "CreateDatasetVersion", + "CreateEvaluator", + "CreateGateway", + "CreateGatewayRateLimit", + "CreateGatewayRule", + "CreateGatewayTarget", + "CreateHarness", + "CreateHarnessEndpoint", + "CreateMemory", + "CreateOauth2CredentialProvider", + "CreateOnlineEvaluationConfig", + "CreatePaymentConnector", + "CreatePaymentCredentialProvider", + "CreatePaymentManager", + "CreatePolicy", + "CreatePolicyEngine", + "CreateRegistry", + "CreateRegistryRecord", + "CreateWorkloadIdentity", + "DeleteAgentRuntime", + "DeleteAgentRuntimeEndpoint", + "DeleteApiKeyCredentialProvider", + "DeleteBrowser", + "DeleteBrowserProfile", + "DeleteCapacityProvider", + "DeleteCodeInterpreter", + "DeleteConfigurationBundle", + "DeleteConsentPortal", + "DeleteDataset", + "DeleteDatasetExamples", + "DeleteEvaluator", + "DeleteGateway", + "DeleteGatewayRateLimit", + "DeleteGatewayRule", + "DeleteGatewayTarget", + "DeleteHarness", + "DeleteHarnessEndpoint", + "DeleteMemory", + "DeleteOauth2CredentialProvider", + "DeleteOnlineEvaluationConfig", + "DeletePaymentConnector", + "DeletePaymentCredentialProvider", + "DeletePaymentManager", + "DeletePolicy", + "DeletePolicyEngine", + "DeleteRegistry", + "DeleteRegistryRecord", + "DeleteResourcePolicy", + "DeleteWorkloadIdentity", + "GetAgentRuntime", + "GetAgentRuntimeEndpoint", + "GetApiKeyCredentialProvider", + "GetBrowser", + "GetBrowserProfile", + "GetCapacityProvider", + "GetCodeInterpreter", + "GetConfigurationBundle", + "GetConfigurationBundleVersion", + "GetConsentPortal", + "GetDataset", + "GetEvaluator", + "GetGateway", + "GetGatewayRateLimit", + "GetGatewayRule", + "GetGatewayTarget", + "GetHarness", + "GetHarnessEndpoint", + "GetMemory", + "GetOauth2CredentialProvider", + "GetOnlineEvaluationConfig", + "GetPaymentConnector", + "GetPaymentCredentialProvider", + "GetPaymentManager", + "GetPolicy", + "GetPolicyEngine", + "GetPolicyEngineSummary", + "GetPolicyGeneration", + "GetPolicyGenerationSummary", + "GetPolicySummary", + "GetRegistry", + "GetRegistryRecord", + "GetResourcePolicy", + "GetTokenVault", + "GetWorkloadIdentity", + "ListAgentRuntimeEndpoints", + "ListAgentRuntimeVersions", + "ListAgentRuntimeVersionsByCapacityProvider", + "ListAgentRuntimes", + "ListApiKeyCredentialProviders", + "ListBrowserProfiles", + "ListBrowsers", + "ListCapacityProviders", + "ListCodeInterpreters", + "ListConfigurationBundleVersions", + "ListConfigurationBundles", + "ListConsentPortals", + "ListDatasetExamples", + "ListDatasetVersions", + "ListDatasets", + "ListEvaluators", + "ListGatewayRateLimits", + "ListGatewayRules", + "ListGatewayTargets", + "ListGateways", + "ListHarnessEndpoints", + "ListHarnessVersions", + "ListHarnesses", + "ListMemories", + "ListOauth2CredentialProviders", + "ListOnlineEvaluationConfigs", + "ListPaymentConnectors", + "ListPaymentCredentialProviders", + "ListPaymentManagers", + "ListPolicies", + "ListPolicyEngineSummaries", + "ListPolicyEngines", + "ListPolicyGenerationAssets", + "ListPolicyGenerationSummaries", + "ListPolicyGenerations", + "ListPolicySummaries", + "ListRegistries", + "ListRegistryRecords", + "ListTagsForResource", + "ListWorkloadIdentities", + "PutResourcePolicy", + "TagResource", + "UntagResource", + "UpdateAgentRuntime", + "UpdateAgentRuntimeEndpoint", + "UpdateApiKeyCredentialProvider", + "UpdateCapacityProvider", + "UpdateConfigurationBundle", + "UpdateConsentPortal", + "UpdateDataset", + "UpdateDatasetExamples", + "UpdateEvaluator", + "UpdateGateway", + "UpdateGatewayRateLimit", + "UpdateGatewayRule", + "UpdateGatewayTarget", + "UpdateHarness", + "UpdateHarnessEndpoint", + "UpdateMemory", + "UpdateOauth2CredentialProvider", + "UpdateOnlineEvaluationConfig", + "UpdatePaymentConnector", + "UpdatePaymentCredentialProvider", + "UpdatePaymentManager", + "UpdatePolicy", + "UpdatePolicyEngine", + "UpdateRegistry", + "UpdateRegistryRecord", + "UpdateRegistryRecordStatus", + "UpdateWorkloadIdentity" + ] + }, + "bedrockagentruntime": { + "protocol": "rest-json", + "servedOps": [ + "CreateInvocation", + "CreateSession", + "DeleteAgentMemory", + "DeleteSession", + "GetAgentMemory", + "GetDocumentContent", + "GetExecutionFlowSnapshot", + "GetFlowExecution", + "GetIngestedDocumentAcl", + "GetInvocationStep", + "GetSession", + "ListFlowExecutionEvents", + "ListFlowExecutions", + "ListInvocationSteps", + "ListInvocations", + "ListSessions", + "ListTagsForResource", + "PutInvocationStep", + "TagResource", + "UntagResource", + "UpdateSession" + ] + }, + "bedrockdataautomation": { + "protocol": "rest-json", + "servedOps": [ + "CreateBlueprint", + "CreateBlueprintVersion", + "CreateDataAutomationLibrary", + "CreateDataAutomationProject", + "DeleteBlueprint", + "DeleteDataAutomationLibrary", + "DeleteDataAutomationProject", + "GetBlueprint", + "GetBlueprintOptimizationStatus", + "GetDataAutomationLibrary", + "GetDataAutomationLibraryEntity", + "GetDataAutomationLibraryIngestionJob", + "GetDataAutomationProject", + "ListBlueprints", + "ListDataAutomationLibraries", + "ListDataAutomationLibraryEntities", + "ListDataAutomationLibraryIngestionJobs", + "ListDataAutomationProjects", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateBlueprint", + "UpdateDataAutomationLibrary", + "UpdateDataAutomationProject" + ] + }, + "bedrockdataautomationruntime": { + "protocol": "json-1.1", + "servedOps": [ + "GetDataAutomationStatus", + "ListTagsForResource", + "TagResource", + "UntagResource" + ] + }, + "bedrockruntime": { + "protocol": "rest-json", + "servedOps": [ + "GetAsyncInvoke", + "ListAsyncInvokes" + ] + }, + "budgets": { + "protocol": "json-1.1", + "servedOps": [ + "CreateBudget", + "CreateBudgetAction", + "CreateNotification", + "CreateSubscriber", + "DeleteBudget", + "DeleteBudgetAction", + "DeleteNotification", + "DeleteSubscriber", + "DescribeBudget", + "DescribeBudgetAction", + "DescribeBudgetActionHistories", + "DescribeBudgetActionsForAccount", + "DescribeBudgetActionsForBudget", + "DescribeBudgetNotificationsForAccount", + "DescribeBudgetPerformanceHistory", + "DescribeBudgets", + "DescribeNotificationsForBudget", + "DescribeSubscribersForNotification", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateBudget", + "UpdateBudgetAction", + "UpdateNotification", + "UpdateSubscriber" + ] + }, + "cleanrooms": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetCollaborationAnalysisTemplate", + "BatchGetSchema", + "BatchGetSchemaAnalysisRule", + "CreateAnalysisTemplate", + "CreateCollaboration", + "CreateCollaborationChangeRequest", + "CreateConfiguredAudienceModelAssociation", + "CreateConfiguredTable", + "CreateConfiguredTableAnalysisRule", + "CreateConfiguredTableAssociation", + "CreateConfiguredTableAssociationAnalysisRule", + "CreateIdMappingTable", + "CreateIdNamespaceAssociation", + "CreateIntermediateTable", + "CreateIntermediateTableAnalysisRule", + "CreateMembership", + "CreatePrivacyBudgetTemplate", + "DeleteAnalysisTemplate", + "DeleteCollaboration", + "DeleteConfiguredAudienceModelAssociation", + "DeleteConfiguredTable", + "DeleteConfiguredTableAnalysisRule", + "DeleteConfiguredTableAssociation", + "DeleteConfiguredTableAssociationAnalysisRule", + "DeleteIdMappingTable", + "DeleteIdNamespaceAssociation", + "DeleteIntermediateTable", + "DeleteIntermediateTableAnalysisRule", + "DeleteMember", + "DeleteMembership", + "DeletePrivacyBudgetTemplate", + "GetAnalysisLogExport", + "GetAnalysisTemplate", + "GetCollaboration", + "GetCollaborationAnalysisTemplate", + "GetCollaborationChangeRequest", + "GetCollaborationConfiguredAudienceModelAssociation", + "GetCollaborationIdNamespaceAssociation", + "GetCollaborationPrivacyBudgetTemplate", + "GetConfiguredAudienceModelAssociation", + "GetConfiguredTable", + "GetConfiguredTableAnalysisRule", + "GetConfiguredTableAssociation", + "GetConfiguredTableAssociationAnalysisRule", + "GetIdMappingTable", + "GetIdNamespaceAssociation", + "GetIntermediateTable", + "GetIntermediateTableAnalysisRule", + "GetMembership", + "GetPrivacyBudgetTemplate", + "GetProtectedJob", + "GetProtectedQuery", + "GetSchema", + "GetSchemaAnalysisRule", + "ListAnalysisLogExports", + "ListAnalysisTemplates", + "ListCollaborationAnalysisTemplates", + "ListCollaborationChangeRequests", + "ListCollaborationConfiguredAudienceModelAssociations", + "ListCollaborationIdNamespaceAssociations", + "ListCollaborationPrivacyBudgetTemplates", + "ListCollaborationPrivacyBudgets", + "ListCollaborations", + "ListConfiguredAudienceModelAssociations", + "ListConfiguredTableAssociations", + "ListConfiguredTables", + "ListIdMappingTables", + "ListIdNamespaceAssociations", + "ListIntermediateTableVersions", + "ListIntermediateTables", + "ListMembers", + "ListMemberships", + "ListPrivacyBudgetTemplates", + "ListPrivacyBudgets", + "ListProtectedJobs", + "ListProtectedQueries", + "ListSchemas", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateAnalysisTemplate", + "UpdateCollaboration", + "UpdateCollaborationChangeRequest", + "UpdateConfiguredAudienceModelAssociation", + "UpdateConfiguredTable", + "UpdateConfiguredTableAnalysisRule", + "UpdateConfiguredTableAssociation", + "UpdateConfiguredTableAssociationAnalysisRule", + "UpdateIdMappingTable", + "UpdateIdNamespaceAssociation", + "UpdateIntermediateTable", + "UpdateIntermediateTableAnalysisRule", + "UpdateMembership", + "UpdatePrivacyBudgetTemplate", + "UpdateProtectedJob", + "UpdateProtectedQuery" + ] + }, + "cloudcontrol": { + "protocol": "", + "servedOps": [ + "BatchGetResources", + "CancelResourceRequest", + "CloneResource", + "CreateResource", + "DeleteResource", + "DescribeResource", + "ExportResources", + "GetHookResults", + "GetResource", + "GetResourceRequestStatus", + "GetResourceSchema", + "GetResourceType", + "ImportResource", + "ListResourceOperations", + "ListResourceRequests", + "ListResourceSchemas", + "ListResourceTypes", + "ListResources", + "ListStackResources", + "ListTagsForResource", + "RefreshResource", + "TagResource", + "UntagResource", + "UpdateResource", + "ValidateResource", + "WaitForResource" + ] + }, + "cloudformation": { + "protocol": "query", + "servedOps": [ + "ActivateType", + "BatchDescribeTypeConfigurations", + "ContinueUpdateRollback", + "CreateChangeSet", + "CreateStack", + "CreateStackInstances", + "CreateStackSet", + "DeactivateType", + "DeleteChangeSet", + "DeleteStack", + "DeleteStackInstances", + "DeleteStackSet", + "DeregisterType", + "DescribeAccountLimits", + "DescribeChangeSet", + "DescribePublisher", + "DescribeStackDriftDetectionStatus", + "DescribeStackEvents", + "DescribeStackInstance", + "DescribeStackResource", + "DescribeStackResourceDrifts", + "DescribeStackResources", + "DescribeStackSet", + "DescribeStackSetOperation", + "DescribeStacks", + "DescribeType", + "DescribeTypeRegistration", + "DetectStackDrift", + "DetectStackResourceDrift", + "ExecuteChangeSet", + "GetStackPolicy", + "GetTemplate", + "GetTemplateSummary", + "ImportStacksToStackSet", + "ListChangeSets", + "ListExports", + "ListImports", + "ListStackInstances", + "ListStackResources", + "ListStackSetOperationResults", + "ListStackSetOperations", + "ListStackSets", + "ListStacks", + "ListTypeRegistrations", + "ListTypeVersions", + "ListTypes", + "PublishType", + "RegisterPublisher", + "RegisterType", + "RollbackStack", + "SetStackPolicy", + "SetTypeConfiguration", + "SetTypeDefaultVersion", + "SignalResource", + "StopStackSetOperation", + "TestType", + "UpdateStack", + "UpdateStackInstances", + "UpdateStackSet", + "UpdateTerminationProtection", + "ValidateTemplate" + ] + }, + "cloudfront": { + "protocol": "rest-xml", + "servedOps": [ + "CreateCachePolicy", + "CreateDistribution", + "CreateDistributionWithTags", + "CreateFunction", + "CreateInvalidation", + "CreateOriginAccessControl", + "CreateOriginRequestPolicy", + "CreateResponseHeadersPolicy", + "DeleteCachePolicy", + "DeleteDistribution", + "DeleteFunction", + "DeleteOriginAccessControl", + "DeleteOriginRequestPolicy", + "DeleteResponseHeadersPolicy", + "DescribeFunction", + "GetCachePolicy", + "GetCachePolicyConfig", + "GetDistribution", + "GetDistributionConfig", + "GetFunction", + "GetInvalidation", + "GetOriginAccessControl", + "GetOriginAccessControlConfig", + "GetOriginRequestPolicy", + "GetOriginRequestPolicyConfig", + "GetResponseHeadersPolicy", + "GetResponseHeadersPolicyConfig", + "ListCachePolicies", + "ListDistributions", + "ListFunctions", + "ListInvalidations", + "ListOriginAccessControls", + "ListOriginRequestPolicies", + "ListResponseHeadersPolicies", + "ListTagsForResource", + "PublishFunction", + "TagResource", + "TestFunction", + "UntagResource", + "UpdateCachePolicy", + "UpdateDistribution", + "UpdateFunction", + "UpdateOriginAccessControl", + "UpdateOriginRequestPolicy", + "UpdateResponseHeadersPolicy" + ] + }, + "cloudhsmv2": { + "protocol": "json-1.1", + "servedOps": [ + "CreateCluster", + "CreateHsm", + "DeleteBackup", + "DeleteCluster", + "DeleteHsm", + "DeleteResourcePolicy", + "DescribeBackups", + "DescribeClusters", + "GetResourcePolicy", + "ListTags", + "ModifyBackupAttributes", + "ModifyCluster", + "PutResourcePolicy", + "TagResource", + "UntagResource" + ] + }, + "cloudsearch": { + "protocol": "query", + "servedOps": [ + "BuildSuggesters", + "CreateDomain", + "DefineAnalysisScheme", + "DefineExpression", + "DefineIndexField", + "DefineSuggester", + "DeleteAnalysisScheme", + "DeleteDomain", + "DeleteExpression", + "DeleteIndexField", + "DeleteSuggester", + "DescribeAnalysisSchemes", + "DescribeAvailabilityOptions", + "DescribeDomainEndpointOptions", + "DescribeDomains", + "DescribeExpressions", + "DescribeIndexFields", + "DescribeScalingParameters", + "DescribeServiceAccessPolicies", + "DescribeSuggesters", + "IndexDocuments", + "ListDomainNames", + "UpdateAvailabilityOptions", + "UpdateDomainEndpointOptions", + "UpdateScalingParameters", + "UpdateServiceAccessPolicies" + ] + }, + "cloudtrail": { + "protocol": "json-1.1", + "servedOps": [ + "AddTags", + "CancelQuery", + "CreateChannel", + "CreateDashboard", + "CreateEventDataStore", + "CreateTrail", + "DeleteChannel", + "DeleteDashboard", + "DeleteEventDataStore", + "DeleteResourcePolicy", + "DeleteTrail", + "DeregisterOrganizationDelegatedAdmin", + "DescribeQuery", + "DescribeTrails", + "DisableFederation", + "EnableFederation", + "GenerateQuery", + "GetChannel", + "GetDashboard", + "GetEventConfiguration", + "GetEventDataStore", + "GetEventSelectors", + "GetImport", + "GetInsightSelectors", + "GetQueryResults", + "GetResourcePolicy", + "GetTrail", + "GetTrailStatus", + "ListChannels", + "ListDashboards", + "ListEventDataStores", + "ListImportFailures", + "ListImports", + "ListInsightsData", + "ListInsightsMetricData", + "ListPublicKeys", + "ListQueries", + "ListTags", + "ListTrails", + "LookupEvents", + "PutEventConfiguration", + "PutEventSelectors", + "PutInsightSelectors", + "PutResourcePolicy", + "RegisterOrganizationDelegatedAdmin", + "RemoveTags", + "RestoreEventDataStore", + "SearchSampleQueries", + "StartDashboardRefresh", + "StartEventDataStoreIngestion", + "StartImport", + "StartLogging", + "StartQuery", + "StopEventDataStoreIngestion", + "StopImport", + "StopLogging", + "UpdateChannel", + "UpdateDashboard", + "UpdateEventDataStore", + "UpdateTrail" + ] + }, + "cloudwatch": { + "protocol": "json-1.0", + "servedOps": [ + "DeleteAlarmMuteRule", + "DeleteAlarms", + "DeleteAnomalyDetector", + "DeleteDashboards", + "DeleteInsightRules", + "DeleteMetricStream", + "DescribeAlarmContributors", + "DescribeAlarmHistory", + "DescribeAlarms", + "DescribeAlarmsForMetric", + "DescribeAnomalyDetectors", + "DescribeInsightRules", + "DisableAlarmActions", + "EnableAlarmActions", + "GetAlarmMuteRule", + "GetDashboard", + "GetInsightRuleReport", + "GetMetricData", + "GetMetricStatistics", + "GetMetricStream", + "GetMetricWidgetImage", + "GetOTelEnrichment", + "ListAlarmMuteRules", + "ListDashboards", + "ListManagedInsightRules", + "ListMetricStreams", + "ListMetrics", + "ListTagsForResource", + "PutAlarmMuteRule", + "PutAnomalyDetector", + "PutCompositeAlarm", + "PutDashboard", + "PutInsightRule", + "PutManagedInsightRules", + "PutMetricAlarm", + "PutMetricData", + "PutMetricStream", + "SetAlarmState", + "TagResource", + "UntagResource" + ] + }, + "cloudwatchlogs": { + "protocol": "json-1.1", + "servedOps": [ + "CreateDelivery", + "CreateExportTask", + "CreateImportTask", + "CreateLogAnomalyDetector", + "CreateLogGroup", + "CreateLogStream", + "CreateLookupTable", + "CreateScheduledQuery", + "DeleteAccountPolicy", + "DeleteDataProtectionPolicy", + "DeleteDelivery", + "DeleteDeliveryDestination", + "DeleteDeliveryDestinationPolicy", + "DeleteDeliverySource", + "DeleteDestination", + "DeleteIndexPolicy", + "DeleteIntegration", + "DeleteLogAnomalyDetector", + "DeleteLogGroup", + "DeleteLogStream", + "DeleteLookupTable", + "DeleteMetricFilter", + "DeleteQueryDefinition", + "DeleteResourcePolicy", + "DeleteRetentionPolicy", + "DeleteScheduledQuery", + "DeleteSubscriptionFilter", + "DeleteTransformer", + "DescribeAccountPolicies", + "DescribeConfigurationTemplates", + "DescribeDeliveries", + "DescribeDeliveryDestinations", + "DescribeDeliverySources", + "DescribeDestinations", + "DescribeExportTasks", + "DescribeFieldIndexes", + "DescribeImportTaskBatches", + "DescribeImportTasks", + "DescribeIndexPolicies", + "DescribeLogGroups", + "DescribeLogStreams", + "DescribeLookupTables", + "DescribeMetricFilters", + "DescribeQueries", + "DescribeQueryDefinitions", + "DescribeResourcePolicies", + "DescribeSubscriptionFilters", + "FilterLogEvents", + "GetDataProtectionPolicy", + "GetDelivery", + "GetDeliveryDestination", + "GetDeliveryDestinationPolicy", + "GetDeliverySource", + "GetIntegration", + "GetLogAnomalyDetector", + "GetLogEvents", + "GetLogFields", + "GetLogGroupFields", + "GetLogObject", + "GetLogRecord", + "GetLookupTable", + "GetQueryResults", + "GetScheduledQuery", + "GetScheduledQueryHistory", + "GetTransformer", + "ListAggregateLogGroupSummaries", + "ListAnomalies", + "ListIntegrations", + "ListLogAnomalyDetectors", + "ListLogGroups", + "ListLogGroupsForQuery", + "ListScheduledQueries", + "ListSourcesForS3TableIntegration", + "ListTagsForResource", + "ListTagsLogGroup", + "PutAccountPolicy", + "PutBearerTokenAuthentication", + "PutDataProtectionPolicy", + "PutDeliveryDestination", + "PutDeliveryDestinationPolicy", + "PutDeliverySource", + "PutDestination", + "PutDestinationPolicy", + "PutIndexPolicy", + "PutIntegration", + "PutLogEvents", + "PutLogGroupDeletionProtection", + "PutMetricFilter", + "PutQueryDefinition", + "PutResourcePolicy", + "PutRetentionPolicy", + "PutSubscriptionFilter", + "PutTransformer", + "TagLogGroup", + "TagResource", + "UntagLogGroup", + "UntagResource", + "UpdateAnomaly", + "UpdateDeliveryConfiguration", + "UpdateLogAnomalyDetector", + "UpdateLookupTable", + "UpdateScheduledQuery" + ] + }, + "codeartifact": { + "protocol": "rest-json", + "servedOps": [ + "AssociateExternalConnection", + "CopyPackageVersions", + "CreateDomain", + "CreatePackageGroup", + "CreateRepository", + "DeleteDomain", + "DeleteDomainPermissionsPolicy", + "DeletePackage", + "DeletePackageGroup", + "DeletePackageVersions", + "DeleteRepository", + "DeleteRepositoryPermissionsPolicy", + "DescribeDomain", + "DescribePackage", + "DescribePackageGroup", + "DescribePackageVersion", + "DescribeRepository", + "DisassociateExternalConnection", + "DisposePackageVersions", + "GetAssociatedPackageGroup", + "GetAuthorizationToken", + "GetDomainPermissionsPolicy", + "GetPackageVersionAsset", + "GetPackageVersionReadme", + "GetRepositoryEndpoint", + "GetRepositoryPermissionsPolicy", + "ListAllowedRepositoriesForGroup", + "ListAssociatedPackages", + "ListDomains", + "ListPackageGroups", + "ListPackageVersionAssets", + "ListPackageVersionDependencies", + "ListPackageVersions", + "ListPackages", + "ListRepositories", + "ListRepositoriesInDomain", + "ListSubPackageGroups", + "ListTagsForResource", + "PublishPackageVersion", + "PutDomainPermissionsPolicy", + "PutPackageOriginConfiguration", + "PutRepositoryPermissionsPolicy", + "TagResource", + "UntagResource", + "UpdatePackageGroup", + "UpdatePackageGroupOriginConfiguration", + "UpdatePackageVersionsStatus", + "UpdateRepository" + ] + }, + "codebuild": { + "protocol": "json-1.1", + "servedOps": [ + "BatchDeleteBuilds", + "BatchGetBuildBatches", + "BatchGetBuilds", + "BatchGetCommandExecutions", + "BatchGetFleets", + "BatchGetProjects", + "BatchGetReportGroups", + "BatchGetReports", + "BatchGetSandboxes", + "CreateFleet", + "CreateProject", + "CreateReportGroup", + "CreateWebhook", + "DeleteBuildBatch", + "DeleteFleet", + "DeleteProject", + "DeleteReport", + "DeleteReportGroup", + "DeleteResourcePolicy", + "DeleteSourceCredentials", + "DeleteWebhook", + "DescribeCodeCoverages", + "DescribeTestCases", + "GetReportGroupTrend", + "GetResourcePolicy", + "ImportSourceCredentials", + "InvalidateProjectCache", + "ListBuildBatches", + "ListBuildBatchesForProject", + "ListBuilds", + "ListBuildsForProject", + "ListCommandExecutionsForSandbox", + "ListCuratedEnvironmentImages", + "ListFleets", + "ListProjects", + "ListReportGroups", + "ListReports", + "ListReportsForReportGroup", + "ListSandboxes", + "ListSandboxesForProject", + "ListSharedProjects", + "ListSharedReportGroups", + "ListSourceCredentials", + "ListTagsForResource", + "PutResourcePolicy", + "RetryBuild", + "StartBuild", + "StopBuild", + "TagResource", + "UntagResource", + "UpdateFleet", + "UpdateProject", + "UpdateProjectVisibility", + "UpdateReportGroup", + "UpdateWebhook" + ] + }, + "codecommit": { + "protocol": "json-1.1", + "servedOps": [ + "AssociateApprovalRuleTemplateWithRepository", + "BatchAssociateApprovalRuleTemplateWithRepositories", + "BatchDescribeMergeConflicts", + "BatchDisassociateApprovalRuleTemplateFromRepositories", + "BatchGetCommits", + "BatchGetRepositories", + "CreateApprovalRuleTemplate", + "CreateBranch", + "CreateCommit", + "CreatePullRequest", + "CreatePullRequestApprovalRule", + "CreateRepository", + "CreateUnreferencedMergeCommit", + "DeleteApprovalRuleTemplate", + "DeleteBranch", + "DeleteCommentContent", + "DeleteFile", + "DeletePullRequestApprovalRule", + "DeleteRepository", + "DescribeMergeConflicts", + "DescribePullRequestEvents", + "DisassociateApprovalRuleTemplateFromRepository", + "EvaluatePullRequestApprovalRules", + "GetApprovalRuleTemplate", + "GetBlob", + "GetBranch", + "GetComment", + "GetCommentReactions", + "GetCommentsForComparedCommit", + "GetCommentsForPullRequest", + "GetCommit", + "GetDifferences", + "GetFile", + "GetFolder", + "GetMergeCommit", + "GetMergeConflicts", + "GetMergeOptions", + "GetPullRequest", + "GetPullRequestApprovalStates", + "GetPullRequestOverrideState", + "GetRepository", + "GetRepositoryTriggers", + "ListApprovalRuleTemplates", + "ListAssociatedApprovalRuleTemplatesForRepository", + "ListBranches", + "ListFileCommitHistory", + "ListPullRequests", + "ListRepositories", + "ListRepositoriesForApprovalRuleTemplate", + "ListTagsForResource", + "MergeBranchesByFastForward", + "MergeBranchesBySquash", + "MergeBranchesByThreeWay", + "MergePullRequestByFastForward", + "MergePullRequestBySquash", + "MergePullRequestByThreeWay", + "OverridePullRequestApprovalRules", + "PostCommentForComparedCommit", + "PostCommentForPullRequest", + "PostCommentReply", + "PutCommentReaction", + "PutFile", + "PutRepositoryTriggers", + "TagResource", + "TestRepositoryTriggers", + "UntagResource", + "UpdateApprovalRuleTemplateContent", + "UpdateApprovalRuleTemplateDescription", + "UpdateApprovalRuleTemplateName", + "UpdateComment", + "UpdateDefaultBranch", + "UpdatePullRequestApprovalRuleContent", + "UpdatePullRequestApprovalState", + "UpdatePullRequestDescription", + "UpdatePullRequestStatus", + "UpdatePullRequestTitle", + "UpdateRepositoryDescription", + "UpdateRepositoryEncryptionKey", + "UpdateRepositoryName" + ] + }, + "codeconnections": { + "protocol": "", + "servedOps": [ + "CreateConnection", + "CreateHost", + "CreateRepositoryLink", + "CreateSyncBlocker", + "CreateSyncConfiguration", + "DeleteConnection", + "DeleteHost", + "DeleteRepositoryLink", + "DeleteSyncConfiguration", + "DescribeConnection", + "GetConnection", + "GetHost", + "GetRepositoryLink", + "GetRepositorySyncStatus", + "GetResourceSyncStatus", + "GetSyncBlockerSummary", + "GetSyncConfiguration", + "ListConnectionOwners", + "ListConnections", + "ListHosts", + "ListRepositoryLinks", + "ListRepositorySyncDefinitions", + "ListSyncBlockerSummaries", + "ListSyncConfigurations", + "ListTagsForResource", + "PassConnection", + "PassRepository", + "StartRepositoryLink", + "TagResource", + "UntagResource", + "UpdateConnection", + "UpdateHost", + "UpdateRepositoryLink", + "UpdateSyncBlocker", + "UpdateSyncConfiguration" + ] + }, + "codedeploy": { + "protocol": "json-1.1", + "servedOps": [ + "BatchGetApplicationRevisions", + "BatchGetApplications", + "BatchGetDeploymentGroups", + "BatchGetDeploymentInstances", + "BatchGetDeploymentTargets", + "BatchGetDeployments", + "BatchGetOnPremisesInstances", + "CreateApplication", + "CreateDeployment", + "CreateDeploymentConfig", + "CreateDeploymentGroup", + "DeleteApplication", + "DeleteDeploymentConfig", + "DeleteDeploymentGroup", + "DeleteGitHubAccountToken", + "DeleteResourcesByExternalId", + "DeregisterOnPremisesInstance", + "GetApplication", + "GetApplicationRevision", + "GetDeployment", + "GetDeploymentConfig", + "GetDeploymentGroup", + "GetDeploymentInstance", + "GetDeploymentTarget", + "GetOnPremisesInstance", + "ListApplicationRevisions", + "ListApplications", + "ListDeploymentConfigs", + "ListDeploymentGroups", + "ListDeploymentInstances", + "ListDeploymentTargets", + "ListDeployments", + "ListGitHubAccountTokenNames", + "ListOnPremisesInstances", + "ListTagsForResource", + "PutLifecycleEventHookExecutionStatus", + "RegisterApplicationRevision", + "RegisterOnPremisesInstance", + "StopDeployment", + "TagResource", + "UntagResource", + "UpdateApplication", + "UpdateDeploymentGroup" + ] + }, + "codeguruprofiler": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetFrameMetricData", + "CreateProfilingGroup", + "DeleteProfilingGroup", + "DescribeProfilingGroup", + "GetFindingsReportAccountSummary", + "GetNotificationConfiguration", + "GetPolicy", + "GetProfile", + "GetRecommendations", + "ListFindingsReports", + "ListProfileTimes", + "ListProfilingGroups", + "ListTagsForResource", + "PutPermission", + "TagResource", + "UntagResource", + "UpdateProfilingGroup" + ] + }, + "codegurureviewer": { + "protocol": "rest-json", + "servedOps": [ + "CreateCodeReview", + "DescribeCodeReview", + "DescribeRecommendationFeedback", + "DescribeRepositoryAssociation", + "ListCodeReviews", + "ListRecommendationFeedback", + "ListRecommendations", + "ListRepositoryAssociations", + "ListTagsForResource", + "PutRecommendationFeedback", + "TagResource", + "UntagResource" + ] + }, + "codegurusecurity": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetFindings", + "CreateScan", + "CreateUploadUrl", + "GetAccountConfiguration", + "GetFindings", + "GetMetricsSummary", + "GetScan", + "ListFindingsMetrics", + "ListScans", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateAccountConfiguration" + ] + }, + "codepipeline": { + "protocol": "json-1.1", + "servedOps": [ + "AcknowledgeJob", + "AcknowledgeThirdPartyJob", + "CreateCustomActionType", + "CreatePipeline", + "DeleteCustomActionType", + "DeletePipeline", + "DeleteWebhook", + "DeregisterWebhookWithThirdParty", + "DisableStageTransition", + "EnableStageTransition", + "GetActionExecution", + "GetActionType", + "GetJobDetails", + "GetPipeline", + "GetPipelineExecution", + "GetPipelineState", + "GetThirdPartyJobDetails", + "ListActionExecutions", + "ListActionTypes", + "ListDeployActionExecutionTargets", + "ListPipelineExecutions", + "ListPipelines", + "ListRuleExecutions", + "ListRuleTypes", + "ListTagsForResource", + "ListWebhooks", + "PollForJobs", + "PollForThirdPartyJobs", + "PutActionRevision", + "PutApprovalResult", + "PutJobFailureResult", + "PutJobSuccessResult", + "PutThirdPartyJobFailureResult", + "PutThirdPartyJobSuccessResult", + "PutWebhook", + "RegisterWebhookWithThirdParty", + "RetryStageExecution", + "RollbackStage", + "StartPipelineExecution", + "StartPipelineExecutionResumption", + "StopPipelineExecution", + "TagResource", + "UntagResource", + "UpdateActionType", + "UpdatePipeline", + "UpdatePipelineSettings" + ] + }, + "codestarconnections": { + "protocol": "json-1.0", + "servedOps": [ + "CreateConnection", + "CreateHost", + "CreateRepositoryLink", + "CreateSyncConfiguration", + "DeleteConnection", + "DeleteHost", + "DeleteRepositoryLink", + "DeleteSyncConfiguration", + "GetConnection", + "GetHost", + "GetRepositoryLink", + "GetRepositorySyncStatus", + "GetResourceSyncStatus", + "GetSyncBlockerSummary", + "GetSyncConfiguration", + "ListConnections", + "ListHosts", + "ListRepositoryLinks", + "ListRepositorySyncDefinitions", + "ListSyncConfigurations", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateHost", + "UpdateRepositoryLink", + "UpdateSyncBlocker", + "UpdateSyncConfiguration" + ] + }, + "cognitoidentity": { + "protocol": "json-1.1", + "servedOps": [ + "CreateIdentityPool", + "DeleteIdentities", + "DeleteIdentityPool", + "DescribeIdentity", + "DescribeIdentityPool", + "GetCredentialsForIdentity", + "GetId", + "GetIdentityPoolRoles", + "GetOpenIdToken", + "GetOpenIdTokenForDeveloperIdentity", + "GetPrincipalTagAttributeMap", + "ListIdentities", + "ListIdentityPools", + "ListTagsForResource", + "LookupDeveloperIdentity", + "MergeDeveloperIdentities", + "SetIdentityPoolRoles", + "SetPrincipalTagAttributeMap", + "TagResource", + "UnlinkDeveloperIdentity", + "UnlinkIdentity", + "UntagResource", + "UpdateIdentityPool" + ] + }, + "cognitoidentityprovider": { + "protocol": "json-1.1", + "servedOps": [ + "AdminAddUserToGroup", + "AdminConfirmSignUp", + "AdminCreateUser", + "AdminDeleteUser", + "AdminDeleteUserAttributes", + "AdminDisableUser", + "AdminEnableUser", + "AdminGetUser", + "AdminInitiateAuth", + "AdminListGroupsForUser", + "AdminRemoveUserFromGroup", + "AdminResetUserPassword", + "AdminRespondToAuthChallenge", + "AdminSetUserPassword", + "AdminUpdateUserAttributes", + "AdminUserGlobalSignOut", + "ChangePassword", + "ConfirmForgotPassword", + "ConfirmSignUp", + "CreateGroup", + "CreateIdentityProvider", + "CreateManagedLoginBranding", + "CreateResourceServer", + "CreateTerms", + "CreateUserImportJob", + "CreateUserPool", + "CreateUserPoolClient", + "CreateUserPoolDomain", + "DeleteGroup", + "DeleteIdentityProvider", + "DeleteManagedLoginBranding", + "DeleteResourceServer", + "DeleteTerms", + "DeleteUser", + "DeleteUserAttributes", + "DeleteUserPool", + "DeleteUserPoolClient", + "DeleteUserPoolClientSecret", + "DeleteUserPoolDomain", + "DeleteWebAuthnCredential", + "DescribeIdentityProvider", + "DescribeManagedLoginBranding", + "DescribeManagedLoginBrandingByClient", + "DescribeResourceServer", + "DescribeRiskConfiguration", + "DescribeTerms", + "DescribeUserImportJob", + "DescribeUserPool", + "DescribeUserPoolClient", + "DescribeUserPoolDomain", + "ForgotPassword", + "GetCSVHeader", + "GetDevice", + "GetGroup", + "GetIdentityProviderByIdentifier", + "GetLogDeliveryConfiguration", + "GetSigningCertificate", + "GetTokensFromRefreshToken", + "GetUICustomization", + "GetUser", + "GetUserAttributeVerificationCode", + "GetUserAuthFactors", + "GetUserPoolMfaConfig", + "GlobalSignOut", + "InitiateAuth", + "ListDevices", + "ListGroups", + "ListIdentityProviders", + "ListResourceServers", + "ListTagsForResource", + "ListTerms", + "ListUserImportJobs", + "ListUserPoolClientSecrets", + "ListUserPoolClients", + "ListUserPools", + "ListUsers", + "ListUsersInGroup", + "ListWebAuthnCredentials", + "RespondToAuthChallenge", + "RevokeToken", + "SetUserPoolMfaConfig", + "SignUp", + "TagResource", + "UntagResource", + "UpdateAuthEventFeedback", + "UpdateDeviceStatus", + "UpdateGroup", + "UpdateIdentityProvider", + "UpdateManagedLoginBranding", + "UpdateResourceServer", + "UpdateTerms", + "UpdateUserAttributes", + "UpdateUserPool", + "UpdateUserPoolClient", + "UpdateUserPoolDomain" + ] + }, + "comprehend": { + "protocol": "json-1.1", + "servedOps": [ + "CreateDataset", + "CreateDocumentClassifier", + "CreateEndpoint", + "CreateEntityRecognizer", + "CreateFlywheel", + "DeleteDocumentClassifier", + "DeleteEndpoint", + "DeleteEntityRecognizer", + "DeleteFlywheel", + "DeleteResourcePolicy", + "DescribeDataset", + "DescribeDocumentClassificationJob", + "DescribeDocumentClassifier", + "DescribeDominantLanguageDetectionJob", + "DescribeEndpoint", + "DescribeEntitiesDetectionJob", + "DescribeEntityRecognizer", + "DescribeEventsDetectionJob", + "DescribeFlywheel", + "DescribeFlywheelIteration", + "DescribeKeyPhrasesDetectionJob", + "DescribePiiEntitiesDetectionJob", + "DescribeResourcePolicy", + "DescribeSentimentDetectionJob", + "DescribeTargetedSentimentDetectionJob", + "DescribeTopicsDetectionJob", + "ListDatasets", + "ListDocumentClassificationJobs", + "ListDocumentClassifierSummaries", + "ListDocumentClassifiers", + "ListDominantLanguageDetectionJobs", + "ListEndpoints", + "ListEntitiesDetectionJobs", + "ListEntityRecognizerSummaries", + "ListEntityRecognizers", + "ListEventsDetectionJobs", + "ListFlywheelIterationHistory", + "ListFlywheels", + "ListKeyPhrasesDetectionJobs", + "ListPiiEntitiesDetectionJobs", + "ListSentimentDetectionJobs", + "ListTagsForResource", + "ListTargetedSentimentDetectionJobs", + "ListTopicsDetectionJobs", + "PutResourcePolicy", + "TagResource", + "UntagResource", + "UpdateEndpoint", + "UpdateFlywheel" + ] + }, + "comprehendmedical": { + "protocol": "json-1.1", + "servedOps": [ + "DescribeEntitiesDetectionV2Job", + "DescribeICD10CMInferenceJob", + "DescribePHIDetectionJob", + "DescribeRxNormInferenceJob", + "DescribeSNOMEDCTInferenceJob", + "ListEntitiesDetectionV2Jobs", + "ListICD10CMInferenceJobs", + "ListPHIDetectionJobs", + "ListRxNormInferenceJobs", + "ListSNOMEDCTInferenceJobs" + ] + }, + "configservice": { + "protocol": "json-1.1", + "servedOps": [ + "BatchGetAggregateResourceConfig", + "BatchGetResourceConfig", + "DeleteAggregationAuthorization", + "DeleteConfigRule", + "DeleteConfigurationAggregator", + "DeleteConfigurationRecorder", + "DeleteConformancePack", + "DeleteDeliveryChannel", + "DeleteEvaluationResults", + "DeleteOrganizationConfigRule", + "DeleteOrganizationConformancePack", + "DeletePendingAggregationRequest", + "DeleteRemediationConfiguration", + "DeleteRemediationExceptions", + "DeleteResourceConfig", + "DeleteRetentionConfiguration", + "DeleteServiceLinkedConfigurationRecorder", + "DeleteStoredQuery", + "DeliverConfigSnapshot", + "DescribeAggregateComplianceByConfigRules", + "DescribeAggregateComplianceByConformancePacks", + "DescribeAggregationAuthorizations", + "DescribeComplianceByConfigRule", + "DescribeComplianceByResource", + "DescribeConfigRuleEvaluationStatus", + "DescribeConfigRules", + "DescribeConfigurationAggregatorSourcesStatus", + "DescribeConfigurationAggregators", + "DescribeConfigurationRecorderStatus", + "DescribeConfigurationRecorders", + "DescribeConformancePackCompliance", + "DescribeConformancePackStatus", + "DescribeConformancePacks", + "DescribeDeliveryChannelStatus", + "DescribeDeliveryChannels", + "DescribeOrganizationConfigRuleStatuses", + "DescribeOrganizationConfigRules", + "DescribeOrganizationConformancePackStatuses", + "DescribeOrganizationConformancePacks", + "DescribePendingAggregationRequests", + "DescribeRemediationConfigurations", + "DescribeRemediationExceptions", + "DescribeRemediationExecutionStatus", + "DescribeRetentionConfigurations", + "GetAggregateComplianceDetailsByConfigRule", + "GetAggregateConfigRuleComplianceSummary", + "GetAggregateConformancePackComplianceSummary", + "GetAggregateDiscoveredResourceCounts", + "GetAggregateResourceConfig", + "GetComplianceDetailsByConfigRule", + "GetComplianceDetailsByResource", + "GetComplianceSummaryByConfigRule", + "GetComplianceSummaryByResourceType", + "GetConformancePackComplianceDetails", + "GetConformancePackComplianceSummary", + "GetCustomRulePolicy", + "GetDiscoveredResourceCounts", + "GetOrganizationConfigRuleDetailedStatus", + "GetOrganizationConformancePackDetailedStatus", + "GetOrganizationCustomRulePolicy", + "GetResourceConfigHistory", + "GetResourceEvaluationSummary", + "GetStoredQuery", + "ListAggregateDiscoveredResources", + "ListConfigurationRecorders", + "ListConformancePackComplianceScores", + "ListDiscoveredResources", + "ListResourceEvaluations", + "ListStoredQueries", + "ListTagsForResource", + "PutAggregationAuthorization", + "PutConfigRule", + "PutConfigurationAggregator", + "PutConfigurationRecorder", + "PutConformancePack", + "PutDeliveryChannel", + "PutEvaluations", + "PutExternalEvaluation", + "PutOrganizationConfigRule", + "PutOrganizationConformancePack", + "PutRemediationConfigurations", + "PutRemediationExceptions", + "PutResourceConfig", + "PutRetentionConfiguration", + "PutServiceLinkedConfigurationRecorder", + "PutStoredQuery", + "StartConfigRulesEvaluation", + "StartConfigurationRecorder", + "StartRemediationExecution", + "StopConfigurationRecorder", + "TagResource", + "UntagResource" + ] + }, + "connect": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetAttachedFileMetadata", + "BatchGetFlowAssociation", + "CreateAgentStatus", + "CreateAttachedFile", + "CreateAuthCode", + "CreateContact", + "CreateContactFlow", + "CreateContactFlowModule", + "CreateContactFlowModuleAlias", + "CreateContactFlowModuleVersion", + "CreateContactFlowVersion", + "CreateDataTable", + "CreateDataTableAttribute", + "CreateEmailAddress", + "CreateEvaluationForm", + "CreateExtractionDefinition", + "CreateHoursOfOperation", + "CreateHoursOfOperationOverride", + "CreateInstance", + "CreateIntegrationAssociation", + "CreateMetric", + "CreateNotification", + "CreateParticipant", + "CreatePersistentContactAssociation", + "CreatePredefinedAttribute", + "CreatePrompt", + "CreatePushNotificationRegistration", + "CreateQueue", + "CreateQuickConnect", + "CreateRoutingProfile", + "CreateRule", + "CreateSecurityProfile", + "CreateTaskTemplate", + "CreateTestCase", + "CreateTrafficDistributionGroup", + "CreateUseCase", + "CreateUser", + "CreateUserHierarchyGroup", + "CreateView", + "CreateViewVersion", + "CreateVocabulary", + "CreateWorkspace", + "CreateWorkspacePage", + "DeleteAttachedFile", + "DeleteContactData", + "DeleteContactEvaluation", + "DeleteContactFlow", + "DeleteContactFlowModule", + "DeleteContactFlowModuleAlias", + "DeleteContactFlowModuleVersion", + "DeleteContactFlowVersion", + "DeleteDataTable", + "DeleteDataTableAttribute", + "DeleteEmailAddress", + "DeleteEvaluationForm", + "DeleteExtractionDefinition", + "DeleteHoursOfOperation", + "DeleteHoursOfOperationOverride", + "DeleteInstance", + "DeleteIntegrationAssociation", + "DeleteMetric", + "DeleteNotification", + "DeletePredefinedAttribute", + "DeletePrompt", + "DeletePushNotificationRegistration", + "DeleteQueue", + "DeleteQuickConnect", + "DeleteRoutingProfile", + "DeleteRule", + "DeleteSecurityProfile", + "DeleteSession", + "DeleteTaskTemplate", + "DeleteTestCase", + "DeleteTrafficDistributionGroup", + "DeleteUseCase", + "DeleteUser", + "DeleteUserHierarchyGroup", + "DeleteView", + "DeleteViewVersion", + "DeleteVocabulary", + "DeleteWorkspace", + "DeleteWorkspaceMedia", + "DeleteWorkspacePage", + "DescribeAgentStatus", + "DescribeAttachedFilesConfiguration", + "DescribeAuthenticationProfile", + "DescribeContact", + "DescribeContactEvaluation", + "DescribeContactFlow", + "DescribeContactFlowModule", + "DescribeContactFlowModuleAlias", + "DescribeDataTable", + "DescribeDataTableAttribute", + "DescribeEmailAddress", + "DescribeEvaluationForm", + "DescribeExtractionDefinition", + "DescribeHoursOfOperation", + "DescribeHoursOfOperationOverride", + "DescribeInstance", + "DescribeInstanceAttribute", + "DescribeInstanceStorageConfig", + "DescribeMetric", + "DescribeNotification", + "DescribePhoneNumber", + "DescribePredefinedAttribute", + "DescribePrompt", + "DescribeQueue", + "DescribeQuickConnect", + "DescribeRoutingProfile", + "DescribeRule", + "DescribeSecurityProfile", + "DescribeTestCase", + "DescribeTrafficDistributionGroup", + "DescribeUser", + "DescribeUserHierarchyGroup", + "DescribeUserHierarchyStructure", + "DescribeView", + "DescribeVocabulary", + "DescribeWorkspace", + "GetAttachedFile", + "GetContactAttributes", + "GetContactMetrics", + "GetCrossRegionRouting", + "GetCurrentMetricData", + "GetCurrentUserData", + "GetEffectiveHoursOfOperations", + "GetEvaluationFormValidation", + "GetFederationToken", + "GetFlowAssociation", + "GetMetricData", + "GetMetricDataV2", + "GetPromptFile", + "GetTaskTemplate", + "GetTestCaseExecutionSummary", + "GetTrafficDistribution", + "ListAgentStatuses", + "ListAnalyticsDataAssociations", + "ListAnalyticsDataLakeDataSets", + "ListApprovedOrigins", + "ListAssociatedContacts", + "ListAttachedFilesConfigurations", + "ListAuthenticationProfiles", + "ListBots", + "ListChildHoursOfOperations", + "ListContactEvaluations", + "ListContactFlowModuleAliases", + "ListContactFlowModuleVersions", + "ListContactFlowModules", + "ListContactFlowVersions", + "ListContactFlows", + "ListContactReferences", + "ListDataTableAttributes", + "ListDataTablePrimaryValues", + "ListDataTableValues", + "ListDataTables", + "ListDefaultVocabularies", + "ListEntitySecurityProfiles", + "ListEvaluationFormVersions", + "ListEvaluationForms", + "ListExtractionDefinitions", + "ListFlowAssociations", + "ListHoursOfOperationOverrides", + "ListHoursOfOperations", + "ListInstanceAttributes", + "ListInstanceStorageConfigs", + "ListInstances", + "ListIntegrationAssociations", + "ListLambdaFunctions", + "ListLexBots", + "ListMetrics", + "ListNotifications", + "ListPhoneNumbers", + "ListPhoneNumbersV2", + "ListPredefinedAttributes", + "ListPrompts", + "ListQueueEmailAddresses", + "ListQueueQuickConnects", + "ListQueues", + "ListQuickConnects", + "ListRealtimeContactAnalysisSegmentsV2", + "ListRoutingProfileManualAssignmentQueues", + "ListRoutingProfileQueues", + "ListRoutingProfiles", + "ListRules", + "ListSecurityKeys", + "ListSecurityProfileApplications", + "ListSecurityProfileFlowModules", + "ListSecurityProfilePermissions", + "ListSecurityProfiles", + "ListTagsForResource", + "ListTaskTemplates", + "ListTestCaseExecutionRecords", + "ListTestCaseExecutions", + "ListTestCases", + "ListTrafficDistributionGroupUsers", + "ListTrafficDistributionGroups", + "ListUseCases", + "ListUserHierarchyGroups", + "ListUserNotifications", + "ListUserProficiencies", + "ListUsers", + "ListViewVersions", + "ListViews", + "ListWorkspaceMedia", + "ListWorkspacePages", + "ListWorkspaces", + "PutUserStatus", + "TagContact", + "TagResource", + "UntagContact", + "UntagResource", + "UpdateAgentStatus", + "UpdateAttachedFilesConfiguration", + "UpdateAuthenticationProfile", + "UpdateContact", + "UpdateContactAttributes", + "UpdateContactEvaluation", + "UpdateContactFlowContent", + "UpdateContactFlowMetadata", + "UpdateContactFlowModuleAlias", + "UpdateContactFlowModuleContent", + "UpdateContactFlowModuleMetadata", + "UpdateContactFlowName", + "UpdateContactRoutingData", + "UpdateContactSchedule", + "UpdateContactTaskTemplate", + "UpdateCrossRegionRouting", + "UpdateDataTableAttribute", + "UpdateDataTableMetadata", + "UpdateDataTablePrimaryValues", + "UpdateEmailAddressMetadata", + "UpdateEvaluationForm", + "UpdateExtractionDefinition", + "UpdateHoursOfOperation", + "UpdateHoursOfOperationOverride", + "UpdateInstanceAttribute", + "UpdateInstanceStorageConfig", + "UpdateMetricContent", + "UpdateMetricMetadata", + "UpdateNotificationContent", + "UpdateParticipantAuthentication", + "UpdateParticipantRoleConfig", + "UpdatePhoneNumber", + "UpdatePhoneNumberMetadata", + "UpdatePredefinedAttribute", + "UpdatePrompt", + "UpdateQueueHoursOfOperation", + "UpdateQueueMaxContacts", + "UpdateQueueName", + "UpdateQueueOutboundCallerConfig", + "UpdateQueueOutboundEmailConfig", + "UpdateQueueStatus", + "UpdateQuickConnectConfig", + "UpdateQuickConnectName", + "UpdateRoutingProfileAgentAvailabilityTimer", + "UpdateRoutingProfileConcurrency", + "UpdateRoutingProfileDefaultOutboundQueue", + "UpdateRoutingProfileName", + "UpdateRoutingProfileQueues", + "UpdateRule", + "UpdateSecurityProfile", + "UpdateTaskTemplate", + "UpdateTestCase", + "UpdateTrafficDistribution", + "UpdateUserConfig", + "UpdateUserHierarchy", + "UpdateUserHierarchyGroupName", + "UpdateUserHierarchyStructure", + "UpdateUserIdentityInfo", + "UpdateUserNotificationStatus", + "UpdateUserPhoneConfig", + "UpdateUserProficiencies", + "UpdateUserRoutingProfile", + "UpdateUserSecurityProfiles", + "UpdateViewContent", + "UpdateViewMetadata", + "UpdateWorkspaceMetadata", + "UpdateWorkspacePage", + "UpdateWorkspaceTheme", + "UpdateWorkspaceVisibility" + ] + }, + "costexplorer": { + "protocol": "json-1.1", + "servedOps": [ + "CreateAnomalyMonitor", + "CreateAnomalySubscription", + "CreateCostCategoryDefinition", + "DeleteAnomalyMonitor", + "DeleteAnomalySubscription", + "DeleteCostCategoryDefinition", + "DescribeCostCategoryDefinition", + "GetAnomalies", + "GetAnomalyMonitors", + "GetAnomalySubscriptions", + "GetApproximateUsageRecords", + "GetCommitmentPurchaseAnalysis", + "GetCostAndUsage", + "GetCostAndUsageComparisons", + "GetCostAndUsageWithResources", + "GetCostCategories", + "GetCostComparisonDrivers", + "GetCostForecast", + "GetDimensionValues", + "GetReservationCoverage", + "GetReservationPurchaseRecommendation", + "GetReservationUtilization", + "GetRightsizingRecommendation", + "GetSavingsPlanPurchaseRecommendationDetails", + "GetSavingsPlansCoverage", + "GetSavingsPlansPurchaseRecommendation", + "GetSavingsPlansUtilization", + "GetSavingsPlansUtilizationDetails", + "GetTags", + "GetUsageForecast", + "ListCommitmentPurchaseAnalyses", + "ListCostAllocationTagBackfillHistory", + "ListCostAllocationTags", + "ListCostCategoryDefinitions", + "ListCostCategoryResourceAssociations", + "ListSavingsPlansPurchaseRecommendationGeneration", + "ListTagsForResource", + "ProvideAnomalyFeedback", + "StartCommitmentPurchaseAnalysis", + "StartCostAllocationTagBackfill", + "StartSavingsPlansPurchaseRecommendationGeneration", + "TagResource", + "UntagResource", + "UpdateAnomalyMonitor", + "UpdateAnomalySubscription", + "UpdateCostAllocationTagsStatus", + "UpdateCostCategoryDefinition" + ] + }, + "databrew": { + "protocol": "rest-json", + "servedOps": [ + "CreateDataset", + "CreateProfileJob", + "CreateProject", + "CreateRecipe", + "CreateRecipeJob", + "CreateRuleset", + "CreateSchedule", + "DeleteDataset", + "DeleteJob", + "DeleteProject", + "DeleteRecipeVersion", + "DeleteRuleset", + "DeleteSchedule", + "DescribeDataset", + "DescribeJob", + "DescribeJobRun", + "DescribeProject", + "DescribeRecipe", + "DescribeRuleset", + "DescribeSchedule", + "ListDatasets", + "ListJobRuns", + "ListJobs", + "ListProjects", + "ListRecipeVersions", + "ListRecipes", + "ListRulesets", + "ListSchedules", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateDataset", + "UpdateProfileJob", + "UpdateProject", + "UpdateRecipe", + "UpdateRecipeJob", + "UpdateRuleset", + "UpdateSchedule" + ] + }, + "datapipeline": { + "protocol": "json-1.1", + "servedOps": [ + "CreatePipeline", + "DeletePipeline", + "DescribeObjects", + "DescribePipelines", + "GetPipelineDefinition", + "ListPipelines", + "PutPipelineDefinition" + ] + }, + "datasync": { + "protocol": "json-1.1", + "servedOps": [ + "CreateAgent", + "CreateLocationAzureBlob", + "CreateLocationEfs", + "CreateLocationFsxLustre", + "CreateLocationFsxOntap", + "CreateLocationFsxOpenZfs", + "CreateLocationFsxWindows", + "CreateLocationHdfs", + "CreateLocationNfs", + "CreateLocationObjectStorage", + "CreateLocationS3", + "CreateLocationSmb", + "CreateTask", + "DeleteAgent", + "DeleteLocation", + "DeleteTask", + "DescribeAgent", + "DescribeLocationAzureBlob", + "DescribeLocationEfs", + "DescribeLocationFsxLustre", + "DescribeLocationFsxOntap", + "DescribeLocationFsxOpenZfs", + "DescribeLocationFsxWindows", + "DescribeLocationHdfs", + "DescribeLocationNfs", + "DescribeLocationObjectStorage", + "DescribeLocationS3", + "DescribeLocationSmb", + "DescribeTask", + "DescribeTaskExecution", + "ListAgents", + "ListLocations", + "ListTagsForResource", + "ListTaskExecutions", + "ListTasks", + "TagResource", + "UntagResource", + "UpdateAgent", + "UpdateLocationAzureBlob", + "UpdateLocationEfs", + "UpdateLocationFsxLustre", + "UpdateLocationFsxOntap", + "UpdateLocationFsxOpenZfs", + "UpdateLocationFsxWindows", + "UpdateLocationHdfs", + "UpdateLocationNfs", + "UpdateLocationObjectStorage", + "UpdateLocationS3", + "UpdateLocationSmb", + "UpdateTask", + "UpdateTaskExecution" + ] + }, + "dax": { + "protocol": "json-1.1", + "servedOps": [ + "CreateCluster", + "CreateParameterGroup", + "CreateSubnetGroup", + "DeleteCluster", + "DeleteParameterGroup", + "DeleteSubnetGroup", + "DescribeClusters", + "DescribeDefaultParameters", + "DescribeEvents", + "DescribeParameterGroups", + "DescribeParameters", + "DescribeSubnetGroups", + "ListTags", + "TagResource", + "UntagResource", + "UpdateCluster", + "UpdateParameterGroup", + "UpdateSubnetGroup" + ] + }, + "devopsagent": { + "protocol": "rest-json", + "servedOps": [ + "CreateAgentSpace", + "CreateAsset", + "CreateAssetFile", + "CreateBacklogTask", + "CreateChat", + "CreatePrivateConnection", + "CreateTrigger", + "DeleteAgentSpace", + "DeleteAsset", + "DeleteAssetFile", + "DeletePrivateConnection", + "DeleteTrigger", + "DeregisterService", + "DescribePrivateConnection", + "GetAccountUsage", + "GetAgentSpace", + "GetAsset", + "GetAssetContent", + "GetAssetFile", + "GetAssociation", + "GetBacklogTask", + "GetOperatorApp", + "GetRecommendation", + "GetService", + "GetTrigger", + "ListAgentSpaces", + "ListAssetFiles", + "ListAssetTypes", + "ListAssetVersions", + "ListAssets", + "ListAssociations", + "ListBacklogTasks", + "ListChats", + "ListExecutions", + "ListGoals", + "ListJournalRecords", + "ListPendingMessages", + "ListPrivateConnections", + "ListRecommendations", + "ListServices", + "ListTagsForResource", + "ListTriggers", + "ListWebhooks", + "RegisterService", + "TagResource", + "UntagResource", + "UpdateAgentSpace", + "UpdateApprovalAction", + "UpdateAsset", + "UpdateAssetFile", + "UpdateAssociation", + "UpdateBacklogTask", + "UpdateGoal", + "UpdateOperatorAppIdpConfig", + "UpdatePrivateConnectionCertificate", + "UpdateRecommendation", + "UpdateTrigger" + ] + }, + "devopsguru": { + "protocol": "rest-json", + "servedOps": [ + "DeleteInsight", + "DescribeAccountHealth", + "DescribeAccountOverview", + "DescribeAnomaly", + "DescribeEventSourcesConfig", + "DescribeFeedback", + "DescribeInsight", + "DescribeOrganizationHealth", + "DescribeOrganizationOverview", + "DescribeOrganizationResourceCollectionHealth", + "DescribeResourceCollectionHealth", + "DescribeServiceIntegration", + "GetCostEstimation", + "GetResourceCollection", + "ListAnomaliesForInsight", + "ListAnomalousLogGroups", + "ListEvents", + "ListInsights", + "ListMonitoredResources", + "ListNotificationChannels", + "ListOrganizationInsights", + "ListRecommendations", + "PutFeedback", + "UpdateEventSourcesConfig", + "UpdateResourceCollection", + "UpdateServiceIntegration" + ] + }, + "directconnect": { + "protocol": "json-1.1", + "servedOps": [ + "CreateBGPPeer", + "CreateConnection", + "CreateDirectConnectGateway", + "CreateDirectConnectGatewayAssociation", + "CreateDirectConnectGatewayAssociationProposal", + "CreateInterconnect", + "CreateLag", + "CreatePrivateVirtualInterface", + "CreatePublicVirtualInterface", + "CreateTransitVirtualInterface", + "DeleteBGPPeer", + "DeleteConnection", + "DeleteDirectConnectGateway", + "DeleteDirectConnectGatewayAssociation", + "DeleteDirectConnectGatewayAssociationProposal", + "DeleteInterconnect", + "DeleteLag", + "DeleteVirtualInterface", + "DescribeConnectionLoa", + "DescribeConnections", + "DescribeConnectionsOnInterconnect", + "DescribeCustomerMetadata", + "DescribeDirectConnectGatewayAssociationProposals", + "DescribeDirectConnectGatewayAssociations", + "DescribeDirectConnectGatewayAttachments", + "DescribeDirectConnectGateways", + "DescribeHostedConnections", + "DescribeInterconnectLoa", + "DescribeInterconnects", + "DescribeLags", + "DescribeLoa", + "DescribeLocations", + "DescribeRouterConfiguration", + "DescribeTags", + "DescribeVirtualGateways", + "DescribeVirtualInterfaces", + "ListVirtualInterfaceRoutes", + "ListVirtualInterfaceTestHistory", + "TagResource", + "UntagResource", + "UpdateConnection", + "UpdateDirectConnectGateway", + "UpdateDirectConnectGatewayAssociation", + "UpdateLag", + "UpdateVirtualInterfaceAttributes" + ] + }, + "directoryservice": { + "protocol": "json-1.1", + "servedOps": [ + "CreateAlias", + "CreateComputer", + "CreateConditionalForwarder", + "CreateDirectory", + "CreateHybridAD", + "CreateLogSubscription", + "CreateMicrosoftAD", + "CreateSnapshot", + "CreateTrust", + "DeleteADAssessment", + "DeleteConditionalForwarder", + "DeleteDirectory", + "DeleteLogSubscription", + "DeleteSnapshot", + "DeleteTrust", + "DeregisterCertificate", + "DeregisterEventTopic", + "DescribeADAssessment", + "DescribeCAEnrollmentPolicy", + "DescribeCertificate", + "DescribeClientAuthenticationSettings", + "DescribeConditionalForwarders", + "DescribeDirectories", + "DescribeDirectoryDataAccess", + "DescribeDomainControllers", + "DescribeEventTopics", + "DescribeHybridADUpdate", + "DescribeLDAPSSettings", + "DescribeRegions", + "DescribeSettings", + "DescribeSharedDirectories", + "DescribeSnapshots", + "DescribeTrusts", + "DescribeUpdateDirectory", + "GetDirectoryLimits", + "GetSnapshotLimits", + "ListADAssessments", + "ListCertificates", + "ListIpRoutes", + "ListLogSubscriptions", + "ListSchemaExtensions", + "ListTagsForResource", + "RegisterCertificate", + "RegisterEventTopic", + "UpdateConditionalForwarder", + "UpdateDirectorySetup", + "UpdateHybridAD", + "UpdateNumberOfDomainControllers", + "UpdateRadius", + "UpdateSettings", + "UpdateTrust" + ] + }, + "dms": { + "protocol": "", + "servedOps": [ + "AddTagsToResource", + "CreateEndpoint", + "CreateEventSubscription", + "CreateReplicationInstance", + "CreateReplicationTask", + "DeleteEndpoint", + "DeleteEventSubscription", + "DeleteReplicationInstance", + "DeleteReplicationTask", + "DescribeAccountAttributes", + "DescribeCertificates", + "DescribeConnections", + "DescribeEndpointTypes", + "DescribeEndpoints", + "DescribeEventCategories", + "DescribeEventSubscriptions", + "DescribeEvents", + "DescribeOrderableReplicationInstances", + "DescribeReplicationInstances", + "DescribeReplicationSubnetGroups", + "DescribeReplicationTaskAssessmentResults", + "DescribeReplicationTasks", + "DescribeTableStatistics", + "ListTagsForResource", + "ModifyEndpoint", + "ModifyReplicationInstance", + "ModifyReplicationTask", + "RebootReplicationInstance", + "ReloadTables", + "RemoveTagsFromResource", + "StartReplicationTask", + "StopReplicationTask", + "TestConnection" + ] + }, + "docdb": { + "protocol": "query", + "servedOps": [ + "AddSourceIdentifierToSubscription", + "AddTagsToResource", + "ApplyPendingMaintenanceAction", + "CopyDBClusterParameterGroup", + "CopyDBClusterSnapshot", + "CreateDBCluster", + "CreateDBClusterParameterGroup", + "CreateDBClusterSnapshot", + "CreateDBInstance", + "CreateDBSubnetGroup", + "CreateEventSubscription", + "CreateGlobalCluster", + "DeleteDBCluster", + "DeleteDBClusterParameterGroup", + "DeleteDBClusterSnapshot", + "DeleteDBInstance", + "DeleteDBSubnetGroup", + "DeleteEventSubscription", + "DeleteGlobalCluster", + "DescribeCertificates", + "DescribeDBClusterParameterGroups", + "DescribeDBClusterParameters", + "DescribeDBClusterSnapshotAttributes", + "DescribeDBClusterSnapshots", + "DescribeDBClusters", + "DescribeDBEngineVersions", + "DescribeDBInstances", + "DescribeDBSubnetGroups", + "DescribeEngineDefaultClusterParameters", + "DescribeEventCategories", + "DescribeEventSubscriptions", + "DescribeEvents", + "DescribeGlobalClusters", + "DescribeOrderableDBInstanceOptions", + "DescribePendingMaintenanceActions", + "FailoverDBCluster", + "FailoverGlobalCluster", + "ListTagsForResource", + "ModifyDBCluster", + "ModifyDBClusterParameterGroup", + "ModifyDBClusterSnapshotAttribute", + "ModifyDBInstance", + "ModifyDBSubnetGroup", + "ModifyEventSubscription", + "ModifyGlobalCluster", + "RebootDBInstance", + "RemoveFromGlobalCluster", + "RemoveSourceIdentifierFromSubscription", + "RemoveTagsFromResource", + "ResetDBClusterParameterGroup", + "RestoreDBClusterFromSnapshot", + "RestoreDBClusterToPointInTime", + "StartDBCluster", + "StopDBCluster", + "SwitchoverGlobalCluster" + ] + }, + "dsql": { + "protocol": "rest-json", + "servedOps": [ + "CreateCluster", + "CreateStream", + "DeleteCluster", + "DeleteClusterPolicy", + "DeleteStream", + "GetCluster", + "GetClusterPolicy", + "GetStream", + "GetVpcEndpointServiceName", + "ListClusters", + "ListStreams", + "ListTagsForResource", + "PutClusterPolicy", + "TagResource", + "UntagResource", + "UpdateCluster" + ] + }, + "dynamodb": { + "protocol": "json-1.0", + "servedOps": [ + "BatchGetItem", + "BatchWriteItem", + "CreateBackup", + "CreateGlobalTable", + "CreateTable", + "DeleteBackup", + "DeleteItem", + "DeleteResourcePolicy", + "DeleteTable", + "DescribeBackup", + "DescribeContinuousBackups", + "DescribeContributorInsights", + "DescribeEndpoints", + "DescribeExport", + "DescribeGlobalTable", + "DescribeGlobalTableSettings", + "DescribeImport", + "DescribeKinesisStreamingDestination", + "DescribeLimits", + "DescribeTable", + "DescribeTableReplicaAutoScaling", + "DescribeTimeToLive", + "GetItem", + "GetResourcePolicy", + "ListBackups", + "ListContributorInsights", + "ListExports", + "ListGlobalTables", + "ListImports", + "ListTables", + "ListTagsOfResource", + "PutItem", + "PutResourcePolicy", + "Query", + "Scan", + "TagResource", + "TransactGetItems", + "TransactWriteItems", + "UntagResource", + "UpdateContinuousBackups", + "UpdateContributorInsights", + "UpdateGlobalTable", + "UpdateGlobalTableSettings", + "UpdateItem", + "UpdateKinesisStreamingDestination", + "UpdateTable", + "UpdateTableReplicaAutoScaling", + "UpdateTimeToLive" + ] + }, + "dynamodbstreams": { + "protocol": "json-1.0", + "servedOps": [ + "AddTagsToStream", + "DescribeContinuousBackups", + "DescribeLimits", + "DescribeStream", + "DescribeStreamSummary", + "DisableStream", + "EnableStream", + "GetRecords", + "GetShardIterator", + "GetShardIteratorBatch", + "GetStreamBillingMode", + "ListShards", + "ListStreamArns", + "ListStreams", + "ListTagsOfStream", + "MergeShards", + "PurgeStream", + "PutRecord", + "RemoveTagsFromStream", + "ResetStreamIterator", + "SplitShard", + "UpdateStream" + ] + }, + "ebs": { + "protocol": "rest-json", + "servedOps": [ + "CompleteSnapshot", + "CopySnapshot", + "DescribeVolumesModifications", + "EnableSnapshotTierArchival", + "GetSnapshotBlock", + "ListChangedBlocks", + "ListSnapshotBlocks", + "ModifySnapshotAttribute", + "ModifyVolume", + "PutSnapshotBlock", + "RestoreSnapshotTier", + "StartSnapshot" + ] + }, + "ec2": { + "protocol": "", + "servedOps": [ + "AllocateAddress", + "AssociateAddress", + "AssociateRouteTable", + "AttachInternetGateway", + "AttachVolume", + "AuthorizeSecurityGroupEgress", + "AuthorizeSecurityGroupIngress", + "CopyImage", + "CopySnapshot", + "CreateImage", + "CreateInternetGateway", + "CreateKeyPair", + "CreateNetworkAcl", + "CreateNetworkAclEntry", + "CreateRoute", + "CreateRouteTable", + "CreateSecurityGroup", + "CreateSnapshot", + "CreateSubnet", + "CreateTags", + "CreateVolume", + "CreateVpc", + "DeleteKeyPair", + "DeleteNetworkAcl", + "DeleteRoute", + "DeleteRouteTable", + "DeleteSecurityGroup", + "DeleteSnapshot", + "DeleteSubnet", + "DeleteTags", + "DeleteVolume", + "DeleteVpc", + "DeregisterImage", + "DescribeAddresses", + "DescribeAvailabilityZones", + "DescribeImages", + "DescribeInstances", + "DescribeInternetGateways", + "DescribeKeyPairs", + "DescribeNetworkAcls", + "DescribeRegions", + "DescribeRouteTables", + "DescribeSecurityGroups", + "DescribeSnapshots", + "DescribeSubnets", + "DescribeTags", + "DescribeVolumes", + "DescribeVpcAttribute", + "DescribeVpcs", + "DetachInternetGateway", + "DetachVolume", + "DisassociateAddress", + "ImportKeyPair", + "ModifyVolume", + "ModifyVpcAttribute", + "RebootInstances", + "RegisterImage", + "ReleaseAddress", + "ReplaceNetworkAclEntry", + "RevokeSecurityGroupEgress", + "RevokeSecurityGroupIngress", + "RunInstances", + "StartInstances", + "StopInstances", + "TerminateInstances" + ] + }, + "ecr": { + "protocol": "json-1.1", + "servedOps": [ + "BatchCheckLayerAvailability", + "BatchDeleteImage", + "BatchGetImage", + "BatchGetRepositoryScanningConfiguration", + "CompleteLayerUpload", + "CreatePullThroughCacheRule", + "CreateRepository", + "CreateRepositoryCreationTemplate", + "DeleteLifecyclePolicy", + "DeletePullThroughCacheRule", + "DeleteRegistryPolicy", + "DeleteRepository", + "DeleteRepositoryCreationTemplate", + "DeleteRepositoryPolicy", + "DeleteSigningConfiguration", + "DeregisterPullTimeUpdateExclusion", + "DescribeImageReplicationStatus", + "DescribeImageScanFindings", + "DescribeImageSigningStatus", + "DescribeImages", + "DescribePullThroughCacheRules", + "DescribeRegistry", + "DescribeRepositories", + "DescribeRepositoryCreationTemplates", + "GetAccountSetting", + "GetAuthorizationToken", + "GetDownloadUrlForLayer", + "GetLifecyclePolicy", + "GetLifecyclePolicyPreview", + "GetRegistryPolicy", + "GetRegistryScanningConfiguration", + "GetRepositoryPolicy", + "GetSigningConfiguration", + "InitiateLayerUpload", + "ListImageReferrers", + "ListImages", + "ListPullTimeUpdateExclusions", + "ListTagsForResource", + "PutAccountSetting", + "PutImage", + "PutImageScanningConfiguration", + "PutImageTagMutability", + "PutLifecyclePolicy", + "PutRegistryPolicy", + "PutRegistryScanningConfiguration", + "PutReplicationConfiguration", + "PutSigningConfiguration", + "RegisterPullTimeUpdateExclusion", + "SetRepositoryPolicy", + "StartImageScan", + "TagResource", + "UntagResource", + "UpdateImageStorageClass", + "UpdatePullThroughCacheRule", + "UpdateRepositoryCreationTemplate", + "UploadLayerPart" + ] + }, + "ecs": { + "protocol": "json-1.1", + "servedOps": [ + "CreateCapacityProvider", + "CreateCluster", + "CreateDaemon", + "CreateExpressGatewayService", + "CreateService", + "CreateTaskSet", + "DeleteAccountSetting", + "DeleteAttributes", + "DeleteCapacityProvider", + "DeleteCluster", + "DeleteDaemon", + "DeleteDaemonTaskDefinition", + "DeleteExpressGatewayService", + "DeleteScalingPolicy", + "DeleteService", + "DeleteTaskDefinitions", + "DeleteTaskSet", + "DeregisterContainerInstance", + "DeregisterScalableTarget", + "DeregisterTaskDefinition", + "DescribeCapacityProviders", + "DescribeClusters", + "DescribeContainerInstances", + "DescribeDaemon", + "DescribeDaemonDeployments", + "DescribeDaemonRevisions", + "DescribeDaemonTaskDefinition", + "DescribeExpressGatewayService", + "DescribeScalableTargets", + "DescribeScalingPolicies", + "DescribeServiceDeployments", + "DescribeServiceRevisions", + "DescribeServices", + "DescribeTaskDefinition", + "DescribeTaskSets", + "DescribeTasks", + "DiscoverPollEndpoint", + "GetTaskProtection", + "ListAccountSettings", + "ListAttributes", + "ListClusters", + "ListContainerInstances", + "ListDaemonDeployments", + "ListDaemonTaskDefinitions", + "ListDaemons", + "ListServiceDeployments", + "ListServices", + "ListServicesByNamespace", + "ListTagsForResource", + "ListTaskDefinitionFamilies", + "ListTaskDefinitions", + "ListTasks", + "PutAccountSetting", + "PutAccountSettingDefault", + "PutAttributes", + "PutClusterCapacityProviders", + "PutScalingPolicy", + "RegisterContainerInstance", + "RegisterDaemonTaskDefinition", + "RegisterScalableTarget", + "RegisterTaskDefinition", + "RunTask", + "StartTask", + "StopTask", + "SubmitContainerStateChange", + "SubmitTaskStateChange", + "TagResource", + "UntagResource", + "UpdateCapacityProvider", + "UpdateCluster", + "UpdateClusterSettings", + "UpdateContainerAgent", + "UpdateContainerInstancesState", + "UpdateDaemon", + "UpdateExpressGatewayService", + "UpdateService", + "UpdateServicePrimaryTaskSet", + "UpdateTaskProtection", + "UpdateTaskSet" + ] + }, + "efs": { + "protocol": "rest-json", + "servedOps": [ + "CreateAccessPoint", + "CreateFileSystem", + "CreateMountTarget", + "DeleteAccessPoint", + "DeleteFileSystem", + "DeleteFileSystemPolicy", + "DeleteMountTarget", + "DescribeAccessPoints", + "DescribeAccountPreferences", + "DescribeBackupPolicy", + "DescribeFileSystemPolicy", + "DescribeFileSystems", + "DescribeLifecycleConfiguration", + "DescribeMountTargetSecurityGroups", + "DescribeMountTargets", + "DescribeReplicationConfigurations", + "ListTagsForResource", + "ModifyMountTargetSecurityGroups", + "PutBackupPolicy", + "PutFileSystemPolicy", + "PutLifecycleConfiguration", + "TagResource", + "UntagResource", + "UpdateFileSystem" + ] + }, + "eks": { + "protocol": "rest-json", + "servedOps": [ + "AssociateAccessPolicy", + "AssociateEncryptionConfig", + "AssociateIdentityProviderConfig", + "CreateAccessEntry", + "CreateAddon", + "CreateCapability", + "CreateCluster", + "CreateEksAnywhereSubscription", + "CreateFargateProfile", + "CreateNodegroup", + "CreatePodIdentityAssociation", + "DeleteAccessEntry", + "DeleteAddon", + "DeleteCapability", + "DeleteCluster", + "DeleteEksAnywhereSubscription", + "DeleteFargateProfile", + "DeleteNodegroup", + "DeletePodIdentityAssociation", + "DeregisterCluster", + "DescribeAccessEntry", + "DescribeAddon", + "DescribeAddonConfiguration", + "DescribeAddonVersions", + "DescribeCapability", + "DescribeCluster", + "DescribeClusterVersions", + "DescribeEksAnywhereSubscription", + "DescribeFargateProfile", + "DescribeIdentityProviderConfig", + "DescribeInsight", + "DescribeInsightsRefresh", + "DescribeNodegroup", + "DescribePodIdentityAssociation", + "DescribeUpdate", + "DisassociateAccessPolicy", + "DisassociateIdentityProviderConfig", + "ListAccessEntries", + "ListAccessPolicies", + "ListAddons", + "ListAssociatedAccessPolicies", + "ListCapabilities", + "ListClusters", + "ListEksAnywhereSubscriptions", + "ListFargateProfiles", + "ListIdentityProviderConfigs", + "ListInsights", + "ListNodegroups", + "ListPodIdentityAssociations", + "ListTagsForResource", + "ListUpdates", + "RegisterCluster", + "StartInsightsRefresh", + "TagResource", + "UntagResource", + "UpdateAccessEntry", + "UpdateAddon", + "UpdateCapability", + "UpdateClusterConfig", + "UpdateClusterVersion", + "UpdateEksAnywhereSubscription", + "UpdateNodegroupConfig", + "UpdateNodegroupVersion", + "UpdatePodIdentityAssociation" + ] + }, + "elasticache": { + "protocol": "query", + "servedOps": [ + "AddTagsToResource", + "AuthorizeCacheSecurityGroupIngress", + "CopySnapshot", + "CreateCacheCluster", + "CreateCacheParameterGroup", + "CreateCacheSecurityGroup", + "CreateCacheSubnetGroup", + "CreateReplicationGroup", + "CreateServerlessCache", + "CreateSnapshot", + "CreateUser", + "CreateUserGroup", + "DecreaseReplicaCount", + "DeleteCacheCluster", + "DeleteCacheParameterGroup", + "DeleteCacheSecurityGroup", + "DeleteCacheSubnetGroup", + "DeleteReplicationGroup", + "DeleteServerlessCache", + "DeleteSnapshot", + "DeleteUser", + "DeleteUserGroup", + "DescribeCacheClusters", + "DescribeCacheParameterGroups", + "DescribeCacheParameters", + "DescribeCacheSecurityGroups", + "DescribeCacheSubnetGroups", + "DescribeEngineDefaultParameters", + "DescribeReplicationGroups", + "DescribeServerlessCaches", + "DescribeSnapshots", + "DescribeUserGroups", + "DescribeUsers", + "IncreaseReplicaCount", + "ListTagsForResource", + "ModifyCacheCluster", + "ModifyCacheParameterGroup", + "ModifyCacheSubnetGroup", + "ModifyReplicationGroup", + "ModifyReplicationGroupShardConfiguration", + "ModifyServerlessCache", + "ModifyUser", + "ModifyUserGroup", + "RebootCacheCluster", + "RemoveTagsFromResource", + "ResetCacheParameterGroup", + "RevokeCacheSecurityGroupIngress", + "TestFailover" + ] + }, + "elasticbeanstalk": { + "protocol": "query", + "servedOps": [ + "AbortEnvironmentUpdate", + "ApplyEnvironmentManagedAction", + "AssociateEnvironmentOperationsRole", + "CheckDNSAvailability", + "ComposeEnvironments", + "CreateApplication", + "CreateApplicationVersion", + "CreateConfigurationTemplate", + "CreateEnvironment", + "CreatePlatformVersion", + "CreateStorageLocation", + "DeleteApplication", + "DeleteApplicationVersion", + "DeleteConfigurationTemplate", + "DeleteEnvironmentConfiguration", + "DeletePlatformVersion", + "DescribeAccountAttributes", + "DescribeApplicationVersions", + "DescribeApplications", + "DescribeConfigurationOptions", + "DescribeConfigurationSettings", + "DescribeEnvironmentHealth", + "DescribeEnvironmentManagedActionHistory", + "DescribeEnvironmentManagedActions", + "DescribeEnvironmentResources", + "DescribeEnvironments", + "DescribeEvents", + "DescribeInstancesHealth", + "DescribePlatformVersion", + "DisassociateEnvironmentOperationsRole", + "ListAvailableSolutionStacks", + "ListPlatformBranches", + "ListPlatformVersions", + "ListTagsForResource", + "RebuildEnvironment", + "RequestEnvironmentInfo", + "RestartAppServer", + "RetrieveEnvironmentInfo", + "SwapEnvironmentCNAMEs", + "TerminateEnvironment", + "UpdateApplication", + "UpdateApplicationResourceLifecycle", + "UpdateApplicationVersion", + "UpdateConfigurationTemplate", + "UpdateEnvironment", + "UpdateTagsForResource", + "ValidateConfigurationSettings" + ] + }, + "elasticloadbalancing": { + "protocol": "query", + "servedOps": [ + "CreateAppCookieStickinessPolicy", + "CreateLBCookieStickinessPolicy", + "CreateLoadBalancer", + "CreateLoadBalancerListeners", + "CreateLoadBalancerPolicy", + "DeleteLoadBalancer", + "DeleteLoadBalancerListeners", + "DeleteLoadBalancerPolicy", + "DeregisterInstancesFromLoadBalancer", + "DescribeAccountLimits", + "DescribeInstanceHealth", + "DescribeLoadBalancerAttributes", + "DescribeLoadBalancerPolicies", + "DescribeLoadBalancerPolicyTypes", + "DescribeLoadBalancers", + "DescribeTags", + "ModifyLoadBalancerAttributes", + "RegisterInstancesWithLoadBalancer" + ] + }, + "elasticloadbalancingv2": { + "protocol": "query", + "servedOps": [ + "AddListenerCertificates", + "AddTags", + "CreateListener", + "CreateLoadBalancer", + "CreateRule", + "CreateTargetGroup", + "DeleteListener", + "DeleteLoadBalancer", + "DeleteRule", + "DeleteTargetGroup", + "DeregisterTargets", + "DescribeAccountLimits", + "DescribeListenerCertificates", + "DescribeListeners", + "DescribeLoadBalancerAttributes", + "DescribeLoadBalancers", + "DescribeRules", + "DescribeSSLPolicies", + "DescribeTags", + "DescribeTargetGroupAttributes", + "DescribeTargetGroups", + "DescribeTargetHealth", + "ModifyListener", + "ModifyLoadBalancerAttributes", + "ModifyRule", + "ModifyTargetGroup", + "ModifyTargetGroupAttributes", + "RegisterTargets", + "RemoveListenerCertificates", + "RemoveTags", + "SetIpAddressType", + "SetRulePriorities", + "SetSecurityGroups", + "SetSubnets" + ] + }, + "elasticsearchservice": { + "protocol": "rest-json", + "servedOps": [ + "AcceptInboundCrossClusterSearchConnection", + "AddTags", + "AssociatePackage", + "AuthorizeVpcEndpointAccess", + "CancelDomainConfigChange", + "CancelElasticsearchServiceSoftwareUpdate", + "CreateElasticsearchDomain", + "CreateOutboundCrossClusterSearchConnection", + "CreatePackage", + "CreateVpcEndpoint", + "DeleteElasticsearchDomain", + "DeleteElasticsearchServiceRole", + "DeleteInboundCrossClusterSearchConnection", + "DeleteOutboundCrossClusterSearchConnection", + "DeletePackage", + "DeleteVpcEndpoint", + "DescribeDomainAutoTunes", + "DescribeDomainChangeProgress", + "DescribeElasticsearchDomain", + "DescribeElasticsearchDomainConfig", + "DescribeElasticsearchDomains", + "DescribeElasticsearchInstanceTypeLimits", + "DescribeInboundCrossClusterSearchConnections", + "DescribeOutboundCrossClusterSearchConnections", + "DescribePackages", + "DescribeReservedElasticsearchInstanceOfferings", + "DescribeReservedElasticsearchInstances", + "DescribeVpcEndpoints", + "DissociatePackage", + "GetCompatibleElasticsearchVersions", + "GetPackageVersionHistory", + "GetUpgradeHistory", + "GetUpgradeStatus", + "ListDomainNames", + "ListDomainsForPackage", + "ListElasticsearchInstanceTypes", + "ListElasticsearchVersions", + "ListPackagesForDomain", + "ListTags", + "ListVpcEndpointAccess", + "ListVpcEndpoints", + "ListVpcEndpointsForDomain", + "PurchaseReservedElasticsearchInstanceOffering", + "RejectInboundCrossClusterSearchConnection", + "RemoveTags", + "RevokeVpcEndpointAccess", + "StartElasticsearchServiceSoftwareUpdate", + "UpdateElasticsearchDomainConfig", + "UpdatePackage", + "UpdateVpcEndpoint", + "UpgradeElasticsearchDomain" + ] + }, + "emr": { + "protocol": "json-1.1", + "servedOps": [ + "AddInstanceFleet", + "AddInstanceGroups", + "AddJobFlowSteps", + "AddTags", + "CancelSteps", + "CreatePersistentAppUI", + "CreateSecurityConfiguration", + "CreateStudio", + "CreateStudioSessionMapping", + "DeleteSecurityConfiguration", + "DeleteStudio", + "DeleteStudioSessionMapping", + "DescribeCluster", + "DescribeJobFlows", + "DescribeNotebookExecution", + "DescribePersistentAppUI", + "DescribeReleaseLabel", + "DescribeSecurityConfiguration", + "DescribeStep", + "DescribeStudio", + "GetAutoTerminationPolicy", + "GetBlockPublicAccessConfiguration", + "GetClusterSessionCredentials", + "GetManagedScalingPolicy", + "GetOnClusterAppUIPresignedURL", + "GetPersistentAppUIPresignedURL", + "GetStudioSessionMapping", + "ListBootstrapActions", + "ListClusters", + "ListInstanceFleets", + "ListInstanceGroups", + "ListInstances", + "ListNotebookExecutions", + "ListReleaseLabels", + "ListSecurityConfigurations", + "ListSteps", + "ListStudioSessionMappings", + "ListStudios", + "ListSupportedInstanceTypes", + "ModifyCluster", + "ModifyInstanceFleet", + "ModifyInstanceGroups", + "PutAutoScalingPolicy", + "PutAutoTerminationPolicy", + "PutBlockPublicAccessConfiguration", + "PutManagedScalingPolicy", + "RemoveAutoScalingPolicy", + "RemoveAutoTerminationPolicy", + "RemoveManagedScalingPolicy", + "RemoveTags", + "RunJobFlow", + "SetKeepJobFlowAliveWhenNoSteps", + "SetTerminationProtection", + "SetUnhealthyNodeReplacement", + "SetVisibleToAllUsers", + "StartNotebookExecution", + "StopNotebookExecution", + "TerminateJobFlows", + "UpdateStudio", + "UpdateStudioSessionMapping" + ] + }, + "emrcontainers": { + "protocol": "rest-json", + "servedOps": [ + "CreateJobTemplate", + "CreateManagedEndpoint", + "CreateSecurityConfiguration", + "CreateVirtualCluster", + "DeleteJobTemplate", + "DeleteManagedEndpoint", + "DeleteSecurityConfiguration", + "DeleteVirtualCluster", + "DescribeJobRun", + "DescribeJobTemplate", + "DescribeManagedEndpoint", + "DescribeSecurityConfiguration", + "DescribeVirtualCluster", + "GetManagedEndpointSessionCredentials", + "ListJobRuns", + "ListJobTemplates", + "ListManagedEndpoints", + "ListSecurityConfigurations", + "ListTagsForResource", + "ListVirtualClusters", + "TagResource", + "UntagResource", + "UpdateVirtualCluster" + ] + }, + "emrserverless": { + "protocol": "rest-json", + "servedOps": [ + "CreateApplication", + "DeleteApplication", + "GetApplication", + "GetDashboardForJobRun", + "GetJobRun", + "GetResourceDashboard", + "GetSession", + "GetSessionEndpoint", + "ListApplications", + "ListJobRunAttempts", + "ListJobRuns", + "ListSessions", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateApplication" + ] + }, + "entityresolution": { + "protocol": "rest-json", + "servedOps": [ + "CreateIdMappingWorkflow", + "CreateIdNamespace", + "CreateMatchingWorkflow", + "CreateSchemaMapping", + "DeleteIdMappingWorkflow", + "DeleteIdNamespace", + "DeleteMatchingWorkflow", + "DeletePolicyStatement", + "DeleteSchemaMapping", + "GetIdMappingJob", + "GetIdMappingWorkflow", + "GetIdNamespace", + "GetMatchId", + "GetMatchingJob", + "GetMatchingWorkflow", + "GetPolicy", + "GetProviderService", + "GetSchemaMapping", + "ListIdMappingJobs", + "ListIdMappingWorkflows", + "ListIdNamespaces", + "ListMatchingJobs", + "ListMatchingWorkflows", + "ListProviderServices", + "ListSchemaMappings", + "ListTagsForResource", + "PutPolicy", + "TagResource", + "UntagResource", + "UpdateIdMappingWorkflow", + "UpdateIdNamespace", + "UpdateMatchingWorkflow", + "UpdateSchemaMapping" + ] + }, + "eventbridge": { + "protocol": "json-1.1", + "servedOps": [ + "CancelReplay", + "CreateApiDestination", + "CreateArchive", + "CreateConnection", + "CreateEndpoint", + "CreateEventBus", + "CreatePartnerEventSource", + "DeleteApiDestination", + "DeleteArchive", + "DeleteConnection", + "DeleteEndpoint", + "DeleteEventBus", + "DeletePartnerEventSource", + "DeleteRule", + "DescribeApiDestination", + "DescribeArchive", + "DescribeConnection", + "DescribeEndpoint", + "DescribeEventBus", + "DescribeEventSource", + "DescribePartnerEventSource", + "DescribeReplay", + "DescribeRule", + "DisableRule", + "EnableRule", + "ListApiDestinations", + "ListArchives", + "ListConnections", + "ListEndpoints", + "ListEventBuses", + "ListEventSources", + "ListPartnerEventSourceAccounts", + "ListPartnerEventSources", + "ListReplays", + "ListRuleNamesByTarget", + "ListRules", + "ListTagsForResource", + "ListTargetsByRule", + "PutEvents", + "PutPartnerEvents", + "PutPermission", + "PutRule", + "PutTargets", + "RemoveTargets", + "StartReplay", + "TagResource", + "TestEventPattern", + "UntagResource", + "UpdateApiDestination", + "UpdateArchive", + "UpdateConnection", + "UpdateEndpoint", + "UpdateEventBus" + ] + }, + "firehose": { + "protocol": "json-1.1", + "servedOps": [ + "AddKinesisSource", + "CreateDeliveryStream", + "DeleteDeliveryStream", + "DescribeDeliveryStream", + "DescribeDeliveryStreamHealth", + "DisableKinesisStreamSource", + "DisableLogging", + "EnableLogging", + "GetDeliveryStreamLogs", + "GetDeliveryStreamMetrics", + "GetKinesisSources", + "GetLoggingConfiguration", + "GetRecordStatistics", + "GetRedshiftDestination", + "ListDeliveryStreams", + "ListRecords", + "ListTagsForDeliveryStream", + "PauseDeliveryStream", + "PutElasticsearchDestination", + "PutExtendedS3Destination", + "PutHttpEndpointDestination", + "PutRecord", + "PutRecordBatch", + "PutRedshiftDestination", + "PutS3Destination", + "PutSplunkDestination", + "ResumeDeliveryStream", + "StartDeliveryStream", + "StartDeliveryStreamEncryption", + "StopDeliveryStream", + "StopDeliveryStreamEncryption", + "TagDeliveryStream", + "UntagDeliveryStream", + "UpdateDestination", + "UpdateElasticsearchDestination", + "UpdateExtendedS3Destination", + "UpdateHttpEndpointDestination", + "UpdateRedshiftDestination", + "UpdateS3Destination", + "UpdateSplunkDestination" + ] + }, + "fis": { + "protocol": "rest-json", + "servedOps": [ + "CancelExperiment", + "CloneExperimentTemplate", + "CreateExperimentTemplate", + "CreateTargetAccountConfiguration", + "DeleteExperimentTemplate", + "DeleteTargetAccountConfiguration", + "GetAction", + "GetExperiment", + "GetExperimentHistory", + "GetExperimentTargetAccountConfiguration", + "GetExperimentTemplate", + "GetExperimentTemplateLogConfiguration", + "GetSafetyLever", + "GetTargetAccountConfiguration", + "GetTargetResourceType", + "ListActions", + "ListExperimentEvents", + "ListExperimentResolvedTargets", + "ListExperimentTargetAccountConfigurations", + "ListExperimentTemplates", + "ListExperiments", + "ListTagsForResource", + "ListTargetAccountConfigurations", + "ListTargetResourceTypes", + "StartExperiment", + "StopExperiment", + "TagResource", + "UntagResource", + "UpdateExperimentTemplate", + "UpdateExperimentTemplateLogConfiguration", + "UpdateSafetyLeverState", + "UpdateTargetAccountConfiguration", + "ValidateExperimentTemplate" + ] + }, + "forecast": { + "protocol": "json-1.1", + "servedOps": [ + "CreateAutoPredictor", + "CreateDataset", + "CreateDatasetGroup", + "CreateDatasetImportJob", + "CreateExplainability", + "CreateExplainabilityExport", + "CreateForecast", + "CreateForecastExportJob", + "CreateMonitor", + "CreatePredictor", + "CreatePredictorBacktestExportJob", + "CreateWhatIfAnalysis", + "CreateWhatIfForecast", + "CreateWhatIfForecastExport", + "DeleteDataset", + "DeleteDatasetGroup", + "DeleteDatasetImportJob", + "DeleteExplainability", + "DeleteExplainabilityExport", + "DeleteForecast", + "DeleteForecastExportJob", + "DeleteMonitor", + "DeletePredictor", + "DeletePredictorBacktestExportJob", + "DeleteResourceTree", + "DeleteWhatIfAnalysis", + "DeleteWhatIfForecast", + "DeleteWhatIfForecastExport", + "DescribeAutoPredictor", + "DescribeDataset", + "DescribeDatasetGroup", + "DescribeDatasetImportJob", + "DescribeExplainability", + "DescribeExplainabilityExport", + "DescribeForecast", + "DescribeForecastExportJob", + "DescribeMonitor", + "DescribePredictor", + "DescribePredictorBacktestExportJob", + "DescribeWhatIfAnalysis", + "DescribeWhatIfForecast", + "DescribeWhatIfForecastExport", + "GetAccuracyMetrics", + "ListDatasetGroups", + "ListDatasetImportJobs", + "ListDatasets", + "ListExplainabilities", + "ListExplainabilityExports", + "ListForecastExportJobs", + "ListForecasts", + "ListMonitorEvaluations", + "ListMonitors", + "ListPredictorBacktestExportJobs", + "ListPredictors", + "ListTagsForResource", + "ListWhatIfAnalyses", + "ListWhatIfForecastExports", + "ListWhatIfForecasts", + "TagResource", + "UntagResource", + "UpdateDatasetGroup" + ] + }, + "forecastquery": { + "protocol": "json-1.1", + "servedOps": [] + }, + "frauddetector": { + "protocol": "json-1.1", + "servedOps": [ + "BatchGetVariable", + "CreateBatchImportJob", + "CreateBatchPredictionJob", + "CreateDetectorVersion", + "CreateList", + "CreateModel", + "CreateModelVersion", + "CreateRule", + "CreateVariable", + "DeleteBatchImportJob", + "DeleteBatchPredictionJob", + "DeleteDetector", + "DeleteDetectorVersion", + "DeleteEntityType", + "DeleteEvent", + "DeleteEventType", + "DeleteEventsByEventType", + "DeleteExternalModel", + "DeleteLabel", + "DeleteList", + "DeleteModel", + "DeleteModelVersion", + "DeleteOutcome", + "DeleteRule", + "DeleteVariable", + "DescribeDetector", + "DescribeModelVersions", + "GetBatchImportJobs", + "GetBatchPredictionJobs", + "GetDeleteEventsByEventTypeStatus", + "GetDetectorVersion", + "GetDetectors", + "GetEntityTypes", + "GetEvent", + "GetEventPrediction", + "GetEventPredictionMetadata", + "GetEventTypes", + "GetExternalModels", + "GetKMSEncryptionKey", + "GetLabels", + "GetListElements", + "GetListsMetadata", + "GetModelVersion", + "GetModels", + "GetOutcomes", + "GetRules", + "GetVariables", + "ListEventPredictions", + "ListTagsForResource", + "PutDetector", + "PutEntityType", + "PutEventType", + "PutExternalModel", + "PutKMSEncryptionKey", + "PutLabel", + "PutOutcome", + "TagResource", + "UntagResource", + "UpdateDetectorVersion", + "UpdateDetectorVersionMetadata", + "UpdateDetectorVersionStatus", + "UpdateEventLabel", + "UpdateList", + "UpdateModel", + "UpdateModelVersion", + "UpdateModelVersionStatus", + "UpdateRuleMetadata", + "UpdateRuleVersion", + "UpdateVariable" + ] + }, + "fsx": { + "protocol": "json-1.1", + "servedOps": [ + "CreateAndAttachS3AccessPoint", + "CreateBackup", + "CreateDataRepositoryAssociation", + "CreateDataRepositoryTask", + "CreateFileCache", + "CreateFileSystem", + "CreateFileSystemFromBackup", + "CreateSnapshot", + "CreateStorageVirtualMachine", + "CreateVolume", + "CreateVolumeFromBackup", + "DeleteBackup", + "DeleteDataRepositoryAssociation", + "DeleteFileCache", + "DeleteFileSystem", + "DeleteSnapshot", + "DeleteStorageVirtualMachine", + "DeleteVolume", + "DescribeBackups", + "DescribeDataRepositoryAssociations", + "DescribeDataRepositoryTasks", + "DescribeFileCaches", + "DescribeFileSystemAliases", + "DescribeFileSystems", + "DescribeS3AccessPointAttachments", + "DescribeSharedVpcConfiguration", + "DescribeSnapshots", + "DescribeStorageVirtualMachines", + "DescribeVolumes", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateDataRepositoryAssociation", + "UpdateFileCache", + "UpdateFileSystem", + "UpdateSharedVpcConfiguration", + "UpdateSnapshot", + "UpdateStorageVirtualMachine", + "UpdateVolume" + ] + }, + "glacier": { + "protocol": "rest-json", + "servedOps": [ + "AbortMultipartUpload", + "AbortVaultLock", + "AddTagsToVault", + "CompleteMultipartUpload", + "CompleteVaultLock", + "CreateVault", + "DeleteArchive", + "DeleteVault", + "DeleteVaultAccessPolicy", + "DeleteVaultNotifications", + "DescribeJob", + "DescribeVault", + "GetDataRetrievalPolicy", + "GetJobOutput", + "GetVaultAccessPolicy", + "GetVaultLock", + "GetVaultNotifications", + "InitiateJob", + "InitiateMultipartUpload", + "InitiateVaultLock", + "ListJobs", + "ListMultipartUploads", + "ListParts", + "ListProvisionedCapacity", + "ListTagsForVault", + "ListVaults", + "PurchaseProvisionedCapacity", + "RemoveTagsFromVault", + "SetDataRetrievalPolicy", + "SetVaultAccessPolicy", + "SetVaultNotifications", + "UploadArchive", + "UploadMultipartPart" + ] + }, + "glue": { + "protocol": "json-1.1", + "servedOps": [ + "BatchCreatePartition", + "BatchDeleteConnection", + "BatchDeletePartition", + "BatchDeleteTable", + "BatchDeleteTableVersion", + "BatchGetBlueprints", + "BatchGetCrawlers", + "BatchGetCustomEntityTypes", + "BatchGetDataQualityResult", + "BatchGetDevEndpoints", + "BatchGetJobs", + "BatchGetPartition", + "BatchGetTableOptimizer", + "BatchGetTriggers", + "BatchGetWorkflows", + "BatchStopJobRun", + "BatchUpdatePartition", + "CreateBlueprint", + "CreateCatalog", + "CreateClassifier", + "CreateColumnStatisticsTaskSettings", + "CreateConnection", + "CreateCrawler", + "CreateCustomEntityType", + "CreateDataQualityRuleset", + "CreateDatabase", + "CreateDevEndpoint", + "CreateGlueIdentityCenterConfiguration", + "CreateIntegration", + "CreateIntegrationResourceProperty", + "CreateIntegrationTableProperties", + "CreateJob", + "CreateMLTransform", + "CreatePartition", + "CreatePartitionIndex", + "CreateRegistry", + "CreateSchema", + "CreateScript", + "CreateSecurityConfiguration", + "CreateSession", + "CreateTable", + "CreateTableOptimizer", + "CreateTrigger", + "CreateUsageProfile", + "CreateUserDefinedFunction", + "CreateWorkflow", + "DeleteBlueprint", + "DeleteCatalog", + "DeleteClassifier", + "DeleteColumnStatisticsForPartition", + "DeleteColumnStatisticsForTable", + "DeleteColumnStatisticsTaskSettings", + "DeleteConnection", + "DeleteConnectionType", + "DeleteCrawler", + "DeleteCustomEntityType", + "DeleteDataQualityRuleset", + "DeleteDatabase", + "DeleteDevEndpoint", + "DeleteGlueIdentityCenterConfiguration", + "DeleteIntegration", + "DeleteIntegrationResourceProperty", + "DeleteIntegrationTableProperties", + "DeleteJob", + "DeleteMLTransform", + "DeletePartition", + "DeletePartitionIndex", + "DeleteRegistry", + "DeleteResourcePolicy", + "DeleteSchema", + "DeleteSchemaVersions", + "DeleteSecurityConfiguration", + "DeleteSession", + "DeleteTable", + "DeleteTableOptimizer", + "DeleteTableVersion", + "DeleteTrigger", + "DeleteUsageProfile", + "DeleteUserDefinedFunction", + "DeleteWorkflow", + "DescribeConnectionType", + "DescribeEntity", + "DescribeInboundIntegrations", + "DescribeIntegrations", + "GetBlueprint", + "GetBlueprintRun", + "GetBlueprintRuns", + "GetCatalog", + "GetCatalogImportStatus", + "GetCatalogs", + "GetClassifier", + "GetClassifiers", + "GetColumnStatisticsForPartition", + "GetColumnStatisticsForTable", + "GetColumnStatisticsTaskRun", + "GetColumnStatisticsTaskRuns", + "GetColumnStatisticsTaskSettings", + "GetConnection", + "GetConnections", + "GetCrawler", + "GetCrawlerMetrics", + "GetCrawlers", + "GetCustomEntityType", + "GetDataCatalogEncryptionSettings", + "GetDataQualityModel", + "GetDataQualityModelResult", + "GetDataQualityResult", + "GetDataQualityRuleRecommendationRun", + "GetDataQualityRuleset", + "GetDataQualityRulesetEvaluationRun", + "GetDatabase", + "GetDatabases", + "GetDataflowGraph", + "GetDevEndpoint", + "GetDevEndpoints", + "GetEntityRecords", + "GetGlueIdentityCenterConfiguration", + "GetIntegrationResourceProperty", + "GetIntegrationTableProperties", + "GetJob", + "GetJobBookmark", + "GetJobRun", + "GetJobRuns", + "GetJobs", + "GetMLTaskRun", + "GetMLTaskRuns", + "GetMLTransform", + "GetMLTransforms", + "GetMapping", + "GetMaterializedViewRefreshTaskRun", + "GetPartition", + "GetPartitionIndexes", + "GetPartitions", + "GetPlan", + "GetRegistry", + "GetResourcePolicies", + "GetResourcePolicy", + "GetSchema", + "GetSchemaByDefinition", + "GetSchemaVersion", + "GetSchemaVersionsDiff", + "GetSecurityConfiguration", + "GetSecurityConfigurations", + "GetSession", + "GetStatement", + "GetTable", + "GetTableOptimizer", + "GetTableVersion", + "GetTableVersions", + "GetTables", + "GetTags", + "GetTrigger", + "GetTriggers", + "GetUnfilteredPartitionMetadata", + "GetUnfilteredPartitionsMetadata", + "GetUnfilteredTableMetadata", + "GetUsageProfile", + "GetUserDefinedFunction", + "GetUserDefinedFunctions", + "GetWorkflow", + "GetWorkflowRun", + "GetWorkflowRunProperties", + "GetWorkflowRuns", + "ListBlueprints", + "ListColumnStatisticsTaskRuns", + "ListConnectionTypes", + "ListCrawlers", + "ListCrawls", + "ListCustomEntityTypes", + "ListDataQualityResults", + "ListDataQualityRuleRecommendationRuns", + "ListDataQualityRulesetEvaluationRuns", + "ListDataQualityRulesets", + "ListDataQualityStatisticAnnotations", + "ListDataQualityStatistics", + "ListDevEndpoints", + "ListEntities", + "ListIntegrationResourceProperties", + "ListJobs", + "ListMLTransforms", + "ListMaterializedViewRefreshTaskRuns", + "ListRegistries", + "ListSchemaVersions", + "ListSchemas", + "ListSessions", + "ListStatements", + "ListTableOptimizerRuns", + "ListTriggers", + "ListUsageProfiles", + "ListWorkflows", + "ModifyIntegration", + "PutDataCatalogEncryptionSettings", + "PutDataQualityProfileAnnotation", + "PutResourcePolicy", + "PutSchemaVersionMetadata", + "PutWorkflowRunProperties", + "RegisterConnectionType", + "RegisterSchemaVersion", + "ResetJobBookmark", + "StartCrawler", + "StartJobRun", + "StartTrigger", + "StopCrawler", + "StopTrigger", + "TagResource", + "UntagResource", + "UpdateBlueprint", + "UpdateCatalog", + "UpdateClassifier", + "UpdateColumnStatisticsForPartition", + "UpdateColumnStatisticsForTable", + "UpdateColumnStatisticsTaskSettings", + "UpdateConnection", + "UpdateCrawler", + "UpdateCrawlerSchedule", + "UpdateDataQualityRuleset", + "UpdateDatabase", + "UpdateDevEndpoint", + "UpdateGlueIdentityCenterConfiguration", + "UpdateIntegrationResourceProperty", + "UpdateIntegrationTableProperties", + "UpdateJob", + "UpdateJobFromSourceControl", + "UpdateMLTransform", + "UpdatePartition", + "UpdateRegistry", + "UpdateSchema", + "UpdateSourceControlFromJob", + "UpdateTable", + "UpdateTableOptimizer", + "UpdateTrigger", + "UpdateUsageProfile", + "UpdateUserDefinedFunction", + "UpdateWorkflow" + ] + }, + "greengrass": { + "protocol": "rest-json", + "servedOps": [ + "CreateConnectorDefinition", + "CreateConnectorDefinitionVersion", + "CreateCoreDefinition", + "CreateCoreDefinitionVersion", + "CreateDeployment", + "CreateDeviceDefinition", + "CreateDeviceDefinitionVersion", + "CreateFunctionDefinition", + "CreateFunctionDefinitionVersion", + "CreateGroup", + "CreateGroupCertificateAuthority", + "CreateGroupVersion", + "CreateLoggerDefinition", + "CreateLoggerDefinitionVersion", + "CreateResourceDefinition", + "CreateResourceDefinitionVersion", + "CreateSoftwareUpdateJob", + "CreateSubscriptionDefinition", + "CreateSubscriptionDefinitionVersion", + "DeleteConnectorDefinition", + "DeleteCoreDefinition", + "DeleteDeviceDefinition", + "DeleteFunctionDefinition", + "DeleteGroup", + "DeleteLoggerDefinition", + "DeleteResourceDefinition", + "DeleteSubscriptionDefinition", + "GetAssociatedRole", + "GetBulkDeploymentStatus", + "GetConnectivityInfo", + "GetConnectorDefinition", + "GetConnectorDefinitionVersion", + "GetCoreDefinition", + "GetCoreDefinitionVersion", + "GetDeploymentStatus", + "GetDeviceDefinition", + "GetDeviceDefinitionVersion", + "GetFunctionDefinition", + "GetFunctionDefinitionVersion", + "GetGroup", + "GetGroupCertificateAuthority", + "GetGroupCertificateConfiguration", + "GetGroupVersion", + "GetLoggerDefinition", + "GetLoggerDefinitionVersion", + "GetResourceDefinition", + "GetResourceDefinitionVersion", + "GetServiceRoleForAccount", + "GetSubscriptionDefinition", + "GetSubscriptionDefinitionVersion", + "GetThingRuntimeConfiguration", + "ListBulkDeploymentDetailedReports", + "ListBulkDeployments", + "ListConnectorDefinitionVersions", + "ListConnectorDefinitions", + "ListCoreDefinitionVersions", + "ListCoreDefinitions", + "ListDeployments", + "ListDeviceDefinitionVersions", + "ListDeviceDefinitions", + "ListFunctionDefinitionVersions", + "ListFunctionDefinitions", + "ListGroupCertificateAuthorities", + "ListGroupVersions", + "ListGroups", + "ListLoggerDefinitionVersions", + "ListLoggerDefinitions", + "ListResourceDefinitionVersions", + "ListResourceDefinitions", + "ListSubscriptionDefinitionVersions", + "ListSubscriptionDefinitions", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateConnectivityInfo", + "UpdateConnectorDefinition", + "UpdateCoreDefinition", + "UpdateDeviceDefinition", + "UpdateFunctionDefinition", + "UpdateGroup", + "UpdateGroupCertificateConfiguration", + "UpdateLoggerDefinition", + "UpdateResourceDefinition", + "UpdateSubscriptionDefinition", + "UpdateThingRuntimeConfiguration" + ] + }, + "guardduty": { + "protocol": "rest-json", + "servedOps": [ + "CreateCustomDetectionRuleAssociation", + "CreateCustomDetectionRuleOrgConfiguration", + "CreateDetector", + "CreateFilter", + "CreateIPSet", + "CreateInvestigation", + "CreateMalwareProtectionPlan", + "CreateMembers", + "CreatePublishingDestination", + "CreateSampleFindings", + "CreateThreatEntitySet", + "CreateThreatIntelSet", + "CreateTrustedEntitySet", + "DeleteCustomDetectionRuleAssociation", + "DeleteCustomDetectionRuleOrgConfiguration", + "DeleteDetector", + "DeleteFilter", + "DeleteIPSet", + "DeleteInvitations", + "DeleteMalwareProtectionPlan", + "DeleteMembers", + "DeletePublishingDestination", + "DeleteThreatEntitySet", + "DeleteThreatIntelSet", + "DeleteTrustedEntitySet", + "DescribeMalwareScans", + "DescribeOrganizationConfiguration", + "DescribePublishingDestination", + "GetAdministratorAccount", + "GetCoverageStatistics", + "GetCustomDetectionRule", + "GetCustomDetectionRuleAssociation", + "GetCustomDetectionRuleOrgConfiguration", + "GetDetector", + "GetFilter", + "GetFindings", + "GetFindingsStatistics", + "GetIPSet", + "GetInvestigation", + "GetInvitationsCount", + "GetMalwareProtectionPlan", + "GetMalwareScan", + "GetMalwareScanSettings", + "GetMasterAccount", + "GetMemberDetectors", + "GetMembers", + "GetOrganizationStatistics", + "GetRemainingFreeTrialDays", + "GetThreatEntitySet", + "GetThreatIntelSet", + "GetTrustedEntitySet", + "GetUsageStatistics", + "ListCoverage", + "ListCustomDetectionRuleAssociations", + "ListCustomDetectionRuleOrgConfigurations", + "ListCustomDetectionRules", + "ListDetectors", + "ListFilters", + "ListFindings", + "ListIPSets", + "ListInvestigations", + "ListInvitations", + "ListMalwareProtectionPlans", + "ListMalwareScans", + "ListMembers", + "ListOrganizationAdminAccounts", + "ListPublishingDestinations", + "ListTagsForResource", + "ListThreatEntitySets", + "ListThreatIntelSets", + "ListTrustedEntitySets", + "TagResource", + "UntagResource", + "UpdateCustomDetectionRuleAssociation", + "UpdateCustomDetectionRuleOrgConfiguration", + "UpdateDetector", + "UpdateFilter", + "UpdateFindingsFeedback", + "UpdateIPSet", + "UpdateMalwareProtectionPlan", + "UpdateMalwareScanSettings", + "UpdateMemberDetectors", + "UpdateOrganizationConfiguration", + "UpdatePublishingDestination", + "UpdateThreatEntitySet", + "UpdateThreatIntelSet", + "UpdateTrustedEntitySet" + ] + }, + "healthlake": { + "protocol": "json-1.0", + "servedOps": [ + "CreateDataTransformationProfile", + "CreateFHIRDatastore", + "DeleteDataTransformationProfile", + "DeleteFHIRDatastore", + "DescribeDataTransformationJob", + "DescribeFHIRDatastore", + "DescribeFHIRExportJob", + "DescribeFHIRImportJob", + "GetDataTransformationProfile", + "ListDataTransformationJobs", + "ListDataTransformationProfileVersions", + "ListDataTransformationProfiles", + "ListFHIRDatastores", + "ListFHIRExportJobs", + "ListFHIRImportJobs", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateDataTransformationProfile", + "UpdateFHIRDatastore", + "UpdateProfileWithAgent" + ] + }, + "iam": { + "protocol": "query", + "servedOps": [ + "AddRoleToInstanceProfile", + "AddUserToGroup", + "AttachGroupPolicy", + "AttachRolePolicy", + "AttachUserPolicy", + "CreateAccessKey", + "CreateGroup", + "CreateInstanceProfile", + "CreatePolicy", + "CreatePolicyVersion", + "CreateRole", + "CreateUser", + "DeleteAccessKey", + "DeleteGroup", + "DeleteGroupPolicy", + "DeleteInstanceProfile", + "DeletePolicy", + "DeleteRole", + "DeleteRolePolicy", + "DeleteUser", + "DeleteUserPolicy", + "DetachGroupPolicy", + "DetachRolePolicy", + "DetachUserPolicy", + "GetGroup", + "GetGroupPolicy", + "GetInstanceProfile", + "GetPolicy", + "GetPolicyVersion", + "GetRole", + "GetRolePolicy", + "GetUser", + "GetUserPolicy", + "ListAccessKeys", + "ListAttachedGroupPolicies", + "ListAttachedRolePolicies", + "ListAttachedUserPolicies", + "ListGroupPolicies", + "ListGroups", + "ListInstanceProfiles", + "ListPolicyVersions", + "ListRolePolicies", + "ListRoleTags", + "ListRoles", + "ListUserPolicies", + "ListUserTags", + "ListUsers", + "PutGroupPolicy", + "PutRolePolicy", + "PutUserPolicy", + "RemoveRoleFromInstanceProfile", + "RemoveUserFromGroup", + "TagRole", + "TagUser", + "UntagRole", + "UntagUser", + "UpdateAccessKey", + "UpdateAssumeRolePolicy", + "UpdateUser" + ] + }, + "identitystore": { + "protocol": "", + "servedOps": [ + "ActivateUser", + "BatchCreateGroups", + "BatchCreateUsers", + "CreateDirectory", + "CreateExternalIdentityProviderConfigurationForApplication", + "CreateGroup", + "CreateGroupMembership", + "CreateUser", + "DeactivateUser", + "DeleteDirectory", + "DeleteGroup", + "DeleteGroupMembership", + "DeleteIdentityProviderConfigurationForApplication", + "DeleteUser", + "DescribeDirectory", + "DescribeGroup", + "DescribeGroupMembership", + "DescribeUser", + "GetGroupId", + "GetGroupMembershipId", + "GetUserId", + "IsMemberInGroups", + "ListDirectories", + "ListGroupMemberships", + "ListGroupMembershipsForMember", + "ListGroups", + "ListIdentityProvidersForApplication", + "ListTagsForResource", + "ListUsers", + "ResetUserPassword", + "SearchGroups", + "SearchUsers", + "TagResource", + "UntagResource", + "UpdateDirectory", + "UpdateGroup", + "UpdateUser" + ] + }, + "inspector2": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetAccountStatus", + "BatchGetCodeSnippet", + "BatchGetFindingDetails", + "BatchGetFreeTrialInfo", + "BatchGetMemberEc2DeepInspectionStatus", + "CreateCisScanConfiguration", + "CreateCodeSecurityIntegration", + "CreateCodeSecurityScanConfiguration", + "CreateConnector", + "CreateFilter", + "CreateFindingsReport", + "CreateSbomExport", + "DeleteCisScanConfiguration", + "DeleteCodeSecurityIntegration", + "DeleteCodeSecurityScanConfiguration", + "DeleteConnector", + "DeleteFilter", + "DescribeOrganizationConfiguration", + "GetCisScanReport", + "GetCisScanResultDetails", + "GetClustersForImage", + "GetCodeSecurityIntegration", + "GetCodeSecurityScan", + "GetCodeSecurityScanConfiguration", + "GetConfiguration", + "GetDelegatedAdminAccount", + "GetEc2DeepInspectionConfiguration", + "GetEncryptionKey", + "GetFindingsReportStatus", + "GetMember", + "GetSbomExport", + "ListAccountPermissions", + "ListCisScanConfigurations", + "ListCisScanResultsAggregatedByChecks", + "ListCisScanResultsAggregatedByTargetResource", + "ListCisScans", + "ListCodeSecurityIntegrations", + "ListCodeSecurityScanConfigurationAssociations", + "ListCodeSecurityScanConfigurations", + "ListConnectorScanConfigurations", + "ListConnectors", + "ListCoverage", + "ListCoverageStatistics", + "ListDelegatedAdminAccounts", + "ListFilters", + "ListFindingAggregations", + "ListFindings", + "ListMembers", + "ListTagsForResource", + "ListUsageTotals", + "TagResource", + "UntagResource", + "UpdateCisScanConfiguration", + "UpdateCodeSecurityIntegration", + "UpdateCodeSecurityScanConfiguration", + "UpdateConfiguration", + "UpdateConnector", + "UpdateConnectorScanConfiguration", + "UpdateEc2DeepInspectionConfiguration", + "UpdateEncryptionKey", + "UpdateFilter", + "UpdateOrgEc2DeepInspectionConfiguration", + "UpdateOrganizationConfiguration" + ] + }, + "iot": { + "protocol": "rest-json", + "servedOps": [ + "AddThingToThingGroup", + "AttachPolicy", + "AttachThingPrincipal", + "CancelJob", + "CreateJob", + "CreateKeysAndCertificate", + "CreatePolicy", + "CreatePolicyVersion", + "CreateRoleAlias", + "CreateThing", + "CreateThingGroup", + "CreateThingType", + "CreateTopicRule", + "DeleteCertificate", + "DeleteJob", + "DeletePolicy", + "DeletePolicyVersion", + "DeleteRoleAlias", + "DeleteThing", + "DeleteThingGroup", + "DeleteThingType", + "DeleteTopicRule", + "DeprecateThingType", + "DescribeCertificate", + "DescribeEndpoint", + "DescribeJob", + "DescribeRoleAlias", + "DescribeThing", + "DescribeThingGroup", + "DescribeThingType", + "DetachPolicy", + "DetachThingPrincipal", + "DisableTopicRule", + "EnableTopicRule", + "GetPolicy", + "GetPolicyVersion", + "GetTopicRule", + "ListAttachedPolicies", + "ListCertificates", + "ListJobs", + "ListPolicies", + "ListPolicyVersions", + "ListPrincipalThings", + "ListRoleAliases", + "ListTagsForResource", + "ListTargetsForPolicy", + "ListThingGroups", + "ListThingGroupsForThing", + "ListThingPrincipals", + "ListThingTypes", + "ListThings", + "ListThingsInThingGroup", + "ListTopicRules", + "RegisterCertificate", + "RegisterCertificateWithoutCA", + "RemoveThingFromThingGroup", + "ReplaceTopicRule", + "SetDefaultPolicyVersion", + "TagResource", + "UntagResource", + "UpdateCertificate", + "UpdateRoleAlias", + "UpdateThing", + "UpdateThingGroup", + "UpdateThingType" + ] + }, + "iotdataplane": { + "protocol": "rest-json", + "servedOps": [ + "DeleteConnection", + "DeleteThingShadow", + "GetRetainedMessage", + "GetThingShadow", + "ListNamedShadowsForThing", + "ListRetainedMessages", + "Publish", + "UpdateThingShadow" + ] + }, + "iotwireless": { + "protocol": "rest-json", + "servedOps": [ + "CreateDestination", + "CreateDeviceProfile", + "CreateFuotaTask", + "CreateMulticastGroup", + "CreateNetworkAnalyzerConfiguration", + "CreateServiceProfile", + "CreateWirelessDevice", + "CreateWirelessGateway", + "DeleteDestination", + "DeleteDeviceProfile", + "DeleteFuotaTask", + "DeleteMulticastGroup", + "DeleteNetworkAnalyzerConfiguration", + "DeleteServiceProfile", + "DeleteWirelessDevice", + "DeleteWirelessGateway", + "GetDestination", + "GetDeviceProfile", + "GetFuotaTask", + "GetMulticastGroup", + "GetNetworkAnalyzerConfiguration", + "GetServiceProfile", + "GetWirelessDevice", + "GetWirelessGateway", + "ListDestinations", + "ListDeviceProfiles", + "ListFuotaTasks", + "ListMulticastGroups", + "ListNetworkAnalyzerConfigurations", + "ListServiceProfiles", + "ListTagsForResource", + "ListWirelessDevices", + "ListWirelessGateways", + "StartFuotaTask", + "TagResource", + "UntagResource", + "UpdateDestination", + "UpdateFuotaTask", + "UpdateMulticastGroup", + "UpdateNetworkAnalyzerConfiguration", + "UpdateWirelessDevice", + "UpdateWirelessGateway" + ] + }, + "ivs": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetChannel", + "BatchGetStreamKey", + "CreateAdConfiguration", + "CreateChannel", + "CreatePlaybackRestrictionPolicy", + "CreateRecordingConfiguration", + "CreateStreamKey", + "DeleteAdConfiguration", + "DeleteChannel", + "DeletePlaybackKeyPair", + "DeletePlaybackRestrictionPolicy", + "DeleteRecordingConfiguration", + "DeleteStreamKey", + "GetAdConfiguration", + "GetChannel", + "GetPlaybackKeyPair", + "GetPlaybackRestrictionPolicy", + "GetRecordingConfiguration", + "GetStream", + "GetStreamKey", + "GetStreamSession", + "ListAdConfigurations", + "ListChannels", + "ListPlaybackKeyPairs", + "ListPlaybackRestrictionPolicies", + "ListRecordingConfigurations", + "ListStreamKeys", + "ListStreamSessions", + "ListStreams", + "ListTagsForResource", + "PutMetadata", + "TagResource", + "UntagResource", + "UpdateAdConfiguration", + "UpdateChannel", + "UpdatePlaybackRestrictionPolicy" + ] + }, + "kafka": { + "protocol": "rest-json", + "servedOps": [ + "BatchAssociateScramSecret", + "BatchDisassociateScramSecret", + "CreateCluster", + "CreateClusterV2", + "CreateConfiguration", + "CreateReplicator", + "CreateTopic", + "CreateVpcConnection", + "DeleteCluster", + "DeleteClusterPolicy", + "DeleteConfiguration", + "DeleteReplicator", + "DeleteTopic", + "DeleteVpcConnection", + "DescribeCluster", + "DescribeClusterOperation", + "DescribeClusterOperationV2", + "DescribeClusterV2", + "DescribeConfiguration", + "DescribeConfigurationRevision", + "DescribeReplicator", + "DescribeTopic", + "DescribeTopicPartitions", + "DescribeVpcConnection", + "GetBootstrapBrokers", + "GetClusterPolicy", + "GetCompatibleKafkaVersions", + "ListClientVpcConnections", + "ListClusterOperations", + "ListClusterOperationsV2", + "ListClusters", + "ListClustersV2", + "ListConfigurationRevisions", + "ListConfigurations", + "ListKafkaVersions", + "ListNodes", + "ListReplicators", + "ListScramSecrets", + "ListTagsForResource", + "ListTopics", + "ListVpcConnections", + "PutClusterPolicy", + "RebootBroker", + "RejectClientVpcConnection", + "TagResource", + "UntagResource", + "UpdateBrokerCount", + "UpdateBrokerStorage", + "UpdateBrokerType", + "UpdateClusterConfiguration", + "UpdateClusterKafkaVersion", + "UpdateConfiguration", + "UpdateConnectivity", + "UpdateMonitoring", + "UpdateRebalancing", + "UpdateReplicationInfo", + "UpdateSecurity", + "UpdateStorage", + "UpdateTopic" + ] + }, + "kendra": { + "protocol": "json-1.1", + "servedOps": [ + "BatchGetDocumentStatus", + "CreateAccessControlConfiguration", + "CreateDataSource", + "CreateExperience", + "CreateFaq", + "CreateFeaturedResultsSet", + "CreateIndex", + "CreateQuerySuggestionsBlockList", + "CreateThesaurus", + "DeleteAccessControlConfiguration", + "DeleteDataSource", + "DeleteExperience", + "DeleteFaq", + "DeleteIndex", + "DeletePrincipalMapping", + "DeleteQuerySuggestionsBlockList", + "DeleteThesaurus", + "DescribeAccessControlConfiguration", + "DescribeDataSource", + "DescribeExperience", + "DescribeFaq", + "DescribeFeaturedResultsSet", + "DescribeIndex", + "DescribePrincipalMapping", + "DescribeQuerySuggestionsBlockList", + "DescribeQuerySuggestionsConfig", + "DescribeThesaurus", + "GetQuerySuggestions", + "GetSnapshots", + "ListAccessControlConfigurations", + "ListDataSourceSyncJobs", + "ListDataSources", + "ListEntityPersonas", + "ListExperienceEntities", + "ListExperiences", + "ListFaqs", + "ListFeaturedResultsSets", + "ListGroupsOlderThanOrderingId", + "ListIndices", + "ListQuerySuggestionsBlockLists", + "ListTagsForResource", + "ListThesauri", + "PutPrincipalMapping", + "TagResource", + "UntagResource", + "UpdateAccessControlConfiguration", + "UpdateDataSource", + "UpdateExperience", + "UpdateFeaturedResultsSet", + "UpdateIndex", + "UpdateQuerySuggestionsBlockList", + "UpdateQuerySuggestionsConfig", + "UpdateThesaurus" + ] + }, + "kendraranking": { + "protocol": "json-1.0", + "servedOps": [ + "CreateRescoreExecutionPlan", + "DeleteRescoreExecutionPlan", + "DescribeRescoreExecutionPlan", + "ListRescoreExecutionPlans", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateRescoreExecutionPlan" + ] + }, + "kinesis": { + "protocol": "json-1.1", + "servedOps": [ + "AddTagsToStream", + "CreateStream", + "DecreaseStreamRetentionPeriod", + "DeleteResourcePolicy", + "DeleteStream", + "DeregisterStreamConsumer", + "DescribeAccountSettings", + "DescribeLimits", + "DescribeStream", + "DescribeStreamConsumer", + "DescribeStreamSummary", + "DisableEnhancedMonitoring", + "EnableEnhancedMonitoring", + "GetRecords", + "GetResourcePolicy", + "GetShardIterator", + "IncreaseStreamRetentionPeriod", + "ListShards", + "ListStreamConsumers", + "ListStreams", + "ListTagsForResource", + "ListTagsForStream", + "MergeShards", + "PutRecord", + "PutRecords", + "PutResourcePolicy", + "RegisterStreamConsumer", + "RemoveTagsFromStream", + "SplitShard", + "StartStreamEncryption", + "StopStreamEncryption", + "SubscribeToShard", + "TagResource", + "UntagResource", + "UpdateAccountSettings", + "UpdateMaxRecordSize", + "UpdateShardCount", + "UpdateStreamMode", + "UpdateStreamWarmThroughput" + ] + }, + "kinesisanalytics": { + "protocol": "json-1.1", + "servedOps": [ + "CreateApplication", + "DeleteApplication", + "DeleteApplicationCloudWatchLoggingOption", + "DeleteApplicationInputProcessingConfiguration", + "DeleteApplicationOutput", + "DeleteApplicationReferenceDataSource", + "DescribeApplication", + "ListApplications", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateApplication" + ] + }, + "kinesisanalyticsv2": { + "protocol": "json-1.1", + "servedOps": [ + "AddApplicationCloudWatchLoggingOption", + "AddApplicationInput", + "AddApplicationInputProcessingConfiguration", + "AddApplicationOutput", + "AddApplicationReferenceDataSource", + "AddApplicationVpcConfiguration", + "CreateApplication", + "CreateApplicationPresignedUrl", + "CreateApplicationSnapshot", + "DeleteApplication", + "DeleteApplicationCloudWatchLoggingOption", + "DeleteApplicationInputProcessingConfiguration", + "DeleteApplicationOutput", + "DeleteApplicationReferenceDataSource", + "DeleteApplicationSnapshot", + "DeleteApplicationVpcConfiguration", + "DescribeApplication", + "DescribeApplicationOperation", + "DescribeApplicationSnapshot", + "DescribeApplicationVersion", + "DiscoverInputSchema", + "ListApplicationOperations", + "ListApplicationSnapshots", + "ListApplicationVersions", + "ListApplications", + "ListTagsForResource", + "RollbackApplication", + "StartApplication", + "StopApplication", + "TagResource", + "UntagResource", + "UpdateApplication", + "UpdateApplicationMaintenanceConfiguration" + ] + }, + "kinesisvideo": { + "protocol": "rest-json", + "servedOps": [ + "CreateSignalingChannel", + "CreateStream", + "DeleteEdgeConfiguration", + "DeleteSignalingChannel", + "DeleteStream", + "DescribeEdgeConfiguration", + "DescribeImageGenerationConfiguration", + "DescribeMappedResourceConfiguration", + "DescribeMediaStorageConfiguration", + "DescribeNotificationConfiguration", + "DescribeSignalingChannel", + "DescribeStream", + "DescribeStreamStorageConfiguration", + "GetDataEndpoint", + "GetSignalingChannelEndpoint", + "ListEdgeAgentConfigurations", + "ListSignalingChannels", + "ListStreams", + "ListTagsForResource", + "ListTagsForStream", + "TagResource", + "TagStream", + "UntagResource", + "UntagStream", + "UpdateDataRetention", + "UpdateImageGenerationConfiguration", + "UpdateMediaStorageConfiguration", + "UpdateNotificationConfiguration", + "UpdateSignalingChannel", + "UpdateStream", + "UpdateStreamStorageConfiguration" + ] + }, + "kms": { + "protocol": "json-1.1", + "servedOps": [ + "CancelKeyDeletion", + "CreateAlias", + "CreateCustomKeyStore", + "CreateGrant", + "CreateKey", + "Decrypt", + "DeleteAlias", + "DeleteCustomKeyStore", + "DeleteImportedKeyMaterial", + "DescribeCustomKeyStores", + "DescribeKey", + "DisableKey", + "EnableKey", + "Encrypt", + "GenerateDataKey", + "GenerateDataKeyPair", + "GenerateDataKeyPairWithoutPlaintext", + "GenerateDataKeyWithoutPlaintext", + "GetKeyPolicy", + "GetKeyRotationStatus", + "GetParametersForImport", + "GetPublicKey", + "ListAliases", + "ListGrants", + "ListKeyPolicies", + "ListKeyRotations", + "ListKeys", + "ListResourceTags", + "ListRetirableGrants", + "PutKeyPolicy", + "ReEncrypt", + "RetireGrant", + "RevokeGrant", + "ScheduleKeyDeletion", + "Sign", + "TagResource", + "UntagResource", + "UpdateAlias", + "UpdateCustomKeyStore", + "UpdateKeyDescription", + "UpdatePrimaryRegion", + "Verify" + ] + }, + "lakeformation": { + "protocol": "rest-json", + "servedOps": [ + "AddLFTagsToResource", + "AssumeDecoratedRoleWithSAML", + "BatchGrantPermissions", + "BatchRevokePermissions", + "CancelTransaction", + "CommitTransaction", + "CreateDataCellsFilter", + "CreateLFTag", + "CreateLFTagExpression", + "CreateLakeFormationIdentityCenterConfiguration", + "CreateLakeFormationOptIn", + "DeleteDataCellsFilter", + "DeleteLFTag", + "DeleteLFTagExpression", + "DeleteLakeFormationIdentityCenterConfiguration", + "DeleteLakeFormationOptIn", + "DeleteObjectsOnCancel", + "DeregisterResource", + "DescribeLakeFormationIdentityCenterConfiguration", + "DescribeResource", + "DescribeTransaction", + "ExtendTransaction", + "GetDataCellsFilter", + "GetDataLakePrincipal", + "GetDataLakeSettings", + "GetEffectivePermissionsForPath", + "GetLFTag", + "GetLFTagExpression", + "GetQueryState", + "GetQueryStatistics", + "GetResourceLFTags", + "GetTableObjects", + "GetTemporaryDataLocationCredentials", + "GetTemporaryGluePartitionCredentials", + "GetTemporaryGlueTableCredentials", + "GetWorkUnitResults", + "GetWorkUnits", + "GrantPermissions", + "ListDataCellsFilter", + "ListLFTagExpressions", + "ListLFTags", + "ListLakeFormationOptIns", + "ListPermissions", + "ListResources", + "ListTableStorageOptimizers", + "ListTransactions", + "PutDataLakeSettings", + "RegisterResource", + "RemoveLFTagsFromResource", + "RevokePermissions", + "SearchDatabasesByLFTags", + "SearchTablesByLFTags", + "StartQueryPlanning", + "StartTransaction", + "UpdateDataCellsFilter", + "UpdateLFTag", + "UpdateLFTagExpression", + "UpdateLakeFormationIdentityCenterConfiguration", + "UpdateResource", + "UpdateTableObjects", + "UpdateTableStorageOptimizer" + ] + }, + "lambda": { + "protocol": "rest-json", + "servedOps": [ + "AddPermission", + "CreateAlias", + "CreateEventSourceMapping", + "CreateFunction", + "DeleteAlias", + "DeleteEventSourceMapping", + "DeleteFunction", + "GetAlias", + "GetEventSourceMapping", + "GetFunction", + "GetPolicy", + "Invoke", + "ListAliases", + "ListEventSourceMappings", + "ListFunctions", + "ListTags", + "ListVersionsByFunction", + "PublishVersion", + "RemovePermission", + "TagResource", + "UntagResource", + "UpdateAlias", + "UpdateEventSourceMapping", + "UpdateFunctionCode", + "UpdateFunctionConfiguration" + ] + }, + "lexmodelbuildingservice": { + "protocol": "rest-json", + "servedOps": [ + "CreateBotVersion", + "CreateIntentVersion", + "CreateSlotTypeVersion", + "DeleteBot", + "DeleteBotAlias", + "DeleteBotChannelAssociation", + "DeleteBotVersion", + "DeleteIntent", + "DeleteIntentVersion", + "DeleteSlotType", + "DeleteSlotTypeVersion", + "DeleteUtterances", + "GetBot", + "GetBotAlias", + "GetBotAliases", + "GetBotChannelAssociation", + "GetBotChannelAssociations", + "GetBotVersions", + "GetBots", + "GetBuiltinIntent", + "GetBuiltinIntents", + "GetBuiltinSlotTypes", + "GetExport", + "GetImport", + "GetIntent", + "GetIntentVersions", + "GetIntents", + "GetMigration", + "GetMigrations", + "GetSlotType", + "GetSlotTypeVersions", + "GetSlotTypes", + "GetUtterancesView", + "ListTagsForResource", + "PutBot", + "PutBotAlias", + "PutIntent", + "PutSlotType", + "TagResource", + "UntagResource" + ] + }, + "lexmodelsv2": { + "protocol": "rest-json", + "servedOps": [ + "CreateBot", + "CreateBotAlias", + "CreateBotLocale", + "CreateBotReplica", + "CreateBotVersion", + "CreateExport", + "CreateIntent", + "CreateResourcePolicy", + "CreateResourcePolicyStatement", + "CreateSlot", + "CreateSlotType", + "CreateTestSetDiscrepancyReport", + "CreateUploadUrl", + "DeleteBot", + "DeleteBotAlias", + "DeleteBotAnalyzerRecommendation", + "DeleteBotLocale", + "DeleteBotReplica", + "DeleteBotVersion", + "DeleteCustomVocabulary", + "DeleteExport", + "DeleteImport", + "DeleteIntent", + "DeleteResourcePolicy", + "DeleteResourcePolicyStatement", + "DeleteSlot", + "DeleteSlotType", + "DeleteTestSet", + "DeleteUtterances", + "DescribeBot", + "DescribeBotAlias", + "DescribeBotAnalyzerRecommendation", + "DescribeBotLocale", + "DescribeBotRecommendation", + "DescribeBotReplica", + "DescribeBotResourceGeneration", + "DescribeBotVersion", + "DescribeCustomVocabularyMetadata", + "DescribeExport", + "DescribeImport", + "DescribeIntent", + "DescribeResourcePolicy", + "DescribeSlot", + "DescribeSlotType", + "DescribeTestExecution", + "DescribeTestSet", + "DescribeTestSetDiscrepancyReport", + "DescribeTestSetGeneration", + "GetTestExecutionArtifactsUrl", + "ListAggregatedUtterances", + "ListBotAliasReplicas", + "ListBotAliases", + "ListBotAnalyzerHistory", + "ListBotLocales", + "ListBotRecommendations", + "ListBotReplicas", + "ListBotResourceGenerations", + "ListBotVersionReplicas", + "ListBotVersions", + "ListBots", + "ListBuiltInIntents", + "ListBuiltInSlotTypes", + "ListCustomVocabularyItems", + "ListExports", + "ListImports", + "ListIntentMetrics", + "ListIntentPaths", + "ListIntentStageMetrics", + "ListIntents", + "ListRecommendedIntents", + "ListSessionAnalyticsData", + "ListSessionMetrics", + "ListSlotTypes", + "ListSlots", + "ListTagsForResource", + "ListTestExecutionResultItems", + "ListTestExecutions", + "ListTestSetRecords", + "ListTestSets", + "ListUtteranceAnalyticsData", + "ListUtteranceMetrics", + "TagResource", + "UntagResource", + "UpdateBot", + "UpdateBotAlias", + "UpdateBotLocale", + "UpdateBotRecommendation", + "UpdateExport", + "UpdateIntent", + "UpdateResourcePolicy", + "UpdateSlot", + "UpdateSlotType", + "UpdateTestSet" + ] + }, + "lexruntimeservice": { + "protocol": "rest-json", + "servedOps": [ + "DeleteSession", + "GetSession", + "PutSession" + ] + }, + "lexruntimev2": { + "protocol": "rest-json", + "servedOps": [ + "DeleteSession", + "GetSession", + "PutSession" + ] + }, + "lookoutequipment": { + "protocol": "json-1.0", + "servedOps": [ + "CreateDataset", + "CreateInferenceScheduler", + "CreateLabel", + "CreateLabelGroup", + "CreateModel", + "CreateRetrainingScheduler", + "DeleteDataset", + "DeleteInferenceScheduler", + "DeleteLabel", + "DeleteLabelGroup", + "DeleteModel", + "DeleteResourcePolicy", + "DeleteRetrainingScheduler", + "DescribeDataIngestionJob", + "DescribeDataset", + "DescribeInferenceScheduler", + "DescribeLabel", + "DescribeLabelGroup", + "DescribeModel", + "DescribeModelVersion", + "DescribeResourcePolicy", + "DescribeRetrainingScheduler", + "ListDataIngestionJobs", + "ListDatasets", + "ListInferenceEvents", + "ListInferenceExecutions", + "ListInferenceSchedulers", + "ListLabelGroups", + "ListLabels", + "ListModelVersions", + "ListModels", + "ListRetrainingSchedulers", + "ListSensorStatistics", + "ListTagsForResource", + "PutResourcePolicy", + "TagResource", + "UntagResource", + "UpdateActiveModelVersion", + "UpdateInferenceScheduler", + "UpdateLabelGroup", + "UpdateModel", + "UpdateRetrainingScheduler" + ] + }, + "macie2": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetCustomDataIdentifiers", + "CreateAllowList", + "CreateClassificationJob", + "CreateCustomDataIdentifier", + "CreateFindingsFilter", + "CreateInvitations", + "CreateMember", + "CreateSampleFindings", + "DeleteAllowList", + "DeleteCustomDataIdentifier", + "DeleteFindingsFilter", + "DeleteInvitations", + "DeleteMember", + "DescribeBuckets", + "DescribeClassificationJob", + "DescribeOrganizationConfiguration", + "GetAdministratorAccount", + "GetAllowList", + "GetAutomatedDiscoveryConfiguration", + "GetBucketStatistics", + "GetClassificationExportConfiguration", + "GetClassificationScope", + "GetCustomDataIdentifier", + "GetFindingStatistics", + "GetFindings", + "GetFindingsFilter", + "GetFindingsPublicationConfiguration", + "GetInvitationsCount", + "GetMacieSession", + "GetMasterAccount", + "GetMember", + "GetResourceProfile", + "GetRevealConfiguration", + "GetSensitiveDataOccurrences", + "GetSensitiveDataOccurrencesAvailability", + "GetSensitivityInspectionTemplate", + "GetUsageStatistics", + "GetUsageTotals", + "ListAllowLists", + "ListAutomatedDiscoveryAccounts", + "ListClassificationJobs", + "ListClassificationScopes", + "ListCustomDataIdentifiers", + "ListFindings", + "ListFindingsFilters", + "ListInvitations", + "ListManagedDataIdentifiers", + "ListMembers", + "ListOrganizationAdminAccounts", + "ListResourceProfileArtifacts", + "ListResourceProfileDetections", + "ListSensitivityInspectionTemplates", + "ListTagsForResource", + "PutClassificationExportConfiguration", + "PutFindingsPublicationConfiguration", + "TagResource", + "UntagResource", + "UpdateAllowList", + "UpdateAutomatedDiscoveryConfiguration", + "UpdateClassificationJob", + "UpdateClassificationScope", + "UpdateFindingsFilter", + "UpdateMacieSession", + "UpdateMemberSession", + "UpdateOrganizationConfiguration", + "UpdateResourceProfile", + "UpdateResourceProfileDetections", + "UpdateRevealConfiguration", + "UpdateSensitivityInspectionTemplate" + ] + }, + "managedblockchain": { + "protocol": "rest-json", + "servedOps": [ + "CreateAccessor", + "CreateMember", + "CreateNetwork", + "CreateNode", + "CreateProposal", + "DeleteAccessor", + "DeleteMember", + "DeleteNetwork", + "DeleteNode", + "GetAccessor", + "GetMember", + "GetNetwork", + "GetNode", + "GetProposal", + "ListAccessors", + "ListInvitations", + "ListMembers", + "ListNetworks", + "ListNodes", + "ListProposals", + "ListTagsForResource", + "RejectInvitation", + "TagResource", + "UntagResource", + "UpdateMember", + "UpdateNode", + "VoteOnProposal" + ] + }, + "mediaconnect": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetRouterInput", + "BatchGetRouterNetworkInterface", + "BatchGetRouterOutput", + "CreateBridge", + "CreateFlow", + "CreateGateway", + "CreateRouterInput", + "CreateRouterNetworkInterface", + "CreateRouterOutput", + "DeleteBridge", + "DeleteFlow", + "DeleteGateway", + "DeleteRouterInput", + "DeleteRouterNetworkInterface", + "DeleteRouterOutput", + "DeregisterGatewayInstance", + "DescribeBridge", + "DescribeFlow", + "DescribeFlowSourceMetadata", + "DescribeFlowSourceThumbnail", + "DescribeGateway", + "DescribeGatewayInstance", + "DescribeOffering", + "DescribeReservation", + "GetRouterInput", + "GetRouterInputSourceMetadata", + "GetRouterInputThumbnail", + "GetRouterNetworkInterface", + "GetRouterOutput", + "ListBridges", + "ListEntitlements", + "ListFlows", + "ListGatewayInstances", + "ListGateways", + "ListOfferings", + "ListReservations", + "ListRouterInputs", + "ListRouterNetworkInterfaces", + "ListRouterOutputs", + "ListTagsForGlobalResource", + "ListTagsForResource", + "TagGlobalResource", + "TagResource", + "UntagGlobalResource", + "UntagResource", + "UpdateBridge", + "UpdateBridgeOutput", + "UpdateBridgeSource", + "UpdateBridgeState", + "UpdateFlow", + "UpdateFlowEntitlement", + "UpdateFlowMediaStream", + "UpdateFlowOutput", + "UpdateFlowSource", + "UpdateGatewayInstance", + "UpdateRouterInput", + "UpdateRouterNetworkInterface", + "UpdateRouterOutput" + ] + }, + "mediaconvert": { + "protocol": "", + "servedOps": [ + "AssociateCertificate", + "CancelJob", + "CreateJob", + "CreateJobTemplate", + "CreatePreset", + "CreateQueue", + "DeleteJobTemplate", + "DeletePolicy", + "DeletePreset", + "DeleteQueue", + "DescribeEndpoints", + "DescribeJob", + "DescribeJobTemplate", + "DescribePreset", + "DescribeQueue", + "DisassociateCertificate", + "GetJob", + "GetJobTemplate", + "GetPolicy", + "GetPreset", + "GetQueue", + "ListJobTemplates", + "ListJobs", + "ListPresets", + "ListQueues", + "ListTagsForResource", + "ListVersions", + "ProbeMediaFile", + "PutPolicy", + "SearchJobs", + "TagResource", + "UntagResource", + "UpdateJobTemplate", + "UpdatePreset", + "UpdateQueue" + ] + }, + "medialive": { + "protocol": "rest-json", + "servedOps": [ + "CreateChannel", + "CreateChannelPlacementGroup", + "CreateCloudWatchAlarmTemplate", + "CreateCloudWatchAlarmTemplateGroup", + "CreateCluster", + "CreateEventBridgeRuleTemplate", + "CreateEventBridgeRuleTemplateGroup", + "CreateInput", + "CreateInputSecurityGroup", + "CreateMultiplex", + "CreateMultiplexProgram", + "CreateNetwork", + "CreateNode", + "CreateNodeRegistrationScript", + "CreatePartnerInput", + "CreateSdiSource", + "CreateSignalMap", + "CreateTags", + "DeleteChannel", + "DeleteChannelPlacementGroup", + "DeleteCloudWatchAlarmTemplate", + "DeleteCloudWatchAlarmTemplateGroup", + "DeleteCluster", + "DeleteEventBridgeRuleTemplate", + "DeleteEventBridgeRuleTemplateGroup", + "DeleteInput", + "DeleteInputSecurityGroup", + "DeleteMultiplex", + "DeleteMultiplexProgram", + "DeleteNetwork", + "DeleteNode", + "DeleteReservation", + "DeleteSchedule", + "DeleteSdiSource", + "DeleteSignalMap", + "DeleteTags", + "DescribeAccountConfiguration", + "DescribeChannel", + "DescribeChannelPlacementGroup", + "DescribeCluster", + "DescribeInput", + "DescribeInputDevice", + "DescribeInputDeviceThumbnail", + "DescribeInputSecurityGroup", + "DescribeMultiplex", + "DescribeMultiplexProgram", + "DescribeNetwork", + "DescribeNode", + "DescribeOffering", + "DescribeReservation", + "DescribeSchedule", + "DescribeSdiSource", + "DescribeThumbnails", + "GetCloudWatchAlarmTemplate", + "GetCloudWatchAlarmTemplateGroup", + "GetEventBridgeRuleTemplate", + "GetEventBridgeRuleTemplateGroup", + "GetSignalMap", + "ListAlerts", + "ListChannelPlacementGroups", + "ListChannels", + "ListCloudWatchAlarmTemplateGroups", + "ListCloudWatchAlarmTemplates", + "ListClusterAlerts", + "ListClusters", + "ListEventBridgeRuleTemplateGroups", + "ListEventBridgeRuleTemplates", + "ListInputDeviceTransfers", + "ListInputDevices", + "ListInputSecurityGroups", + "ListInputs", + "ListMultiplexAlerts", + "ListMultiplexPrograms", + "ListMultiplexes", + "ListNetworks", + "ListNodes", + "ListOfferings", + "ListReservations", + "ListSdiSources", + "ListSignalMaps", + "ListTagsForResource", + "ListVersions", + "UpdateAccountConfiguration", + "UpdateChannel", + "UpdateChannelClass", + "UpdateChannelPlacementGroup", + "UpdateCloudWatchAlarmTemplate", + "UpdateCloudWatchAlarmTemplateGroup", + "UpdateCluster", + "UpdateEventBridgeRuleTemplate", + "UpdateEventBridgeRuleTemplateGroup", + "UpdateInput", + "UpdateInputDevice", + "UpdateInputSecurityGroup", + "UpdateMultiplex", + "UpdateMultiplexProgram", + "UpdateNetwork", + "UpdateNode", + "UpdateNodeState", + "UpdateReservation", + "UpdateSdiSource" + ] + }, + "mediapackage": { + "protocol": "rest-json", + "servedOps": [ + "CreateChannel", + "CreateHarvestJob", + "CreateOriginEndpoint", + "DeleteChannel", + "DeleteOriginEndpoint", + "DescribeChannel", + "DescribeHarvestJob", + "DescribeOriginEndpoint", + "ListChannels", + "ListHarvestJobs", + "ListOriginEndpoints", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateChannel", + "UpdateOriginEndpoint" + ] + }, + "mediapackagev2": { + "protocol": "rest-json", + "servedOps": [ + "CreateChannel", + "CreateChannelGroup", + "CreateHarvestJob", + "CreateOriginEndpoint", + "DeleteChannel", + "DeleteChannelGroup", + "DeleteChannelPolicy", + "DeleteOriginEndpoint", + "DeleteOriginEndpointPolicy", + "GetChannel", + "GetChannelGroup", + "GetChannelPolicy", + "GetHarvestJob", + "GetOriginEndpoint", + "GetOriginEndpointPolicy", + "ListChannelGroups", + "ListChannels", + "ListHarvestJobs", + "ListOriginEndpoints", + "ListTagsForResource", + "PutChannelPolicy", + "PutOriginEndpointPolicy", + "TagResource", + "UntagResource", + "UpdateChannel", + "UpdateChannelGroup", + "UpdateOriginEndpoint" + ] + }, + "mediastore": { + "protocol": "json-1.1", + "servedOps": [ + "CreateContainer", + "DeleteContainer", + "DeleteContainerPolicy", + "DeleteCorsPolicy", + "DeleteLifecyclePolicy", + "DeleteMetricPolicy", + "DescribeContainer", + "GetContainerPolicy", + "GetCorsPolicy", + "GetLifecyclePolicy", + "GetMetricPolicy", + "ListContainers", + "ListTagsForResource", + "PutContainerPolicy", + "PutCorsPolicy", + "PutLifecyclePolicy", + "PutMetricPolicy", + "TagResource", + "UntagResource" + ] + }, + "mediastoredata": { + "protocol": "rest-json", + "servedOps": [ + "DeleteObject", + "DescribeObject", + "GetObject", + "ListItems", + "PutObject" + ] + }, + "memorydb": { + "protocol": "json-1.1", + "servedOps": [ + "BatchUpdateCluster", + "CopySnapshot", + "CreateACL", + "CreateCluster", + "CreateMultiRegionCluster", + "CreateParameterGroup", + "CreateSnapshot", + "CreateSubnetGroup", + "CreateUser", + "DeleteACL", + "DeleteCluster", + "DeleteMultiRegionCluster", + "DeleteParameterGroup", + "DeleteSnapshot", + "DeleteSubnetGroup", + "DeleteUser", + "DescribeACLs", + "DescribeClusters", + "DescribeEngineVersions", + "DescribeEvents", + "DescribeMultiRegionClusters", + "DescribeMultiRegionParameterGroups", + "DescribeMultiRegionParameters", + "DescribeParameterGroups", + "DescribeParameters", + "DescribeReservedNodes", + "DescribeReservedNodesOfferings", + "DescribeServiceUpdates", + "DescribeSnapshots", + "DescribeSubnetGroups", + "DescribeUsers", + "FailoverShard", + "ListAllowedMultiRegionClusterUpdates", + "ListAllowedNodeTypeUpdates", + "ListTags", + "PurchaseReservedNodesOffering", + "ResetParameterGroup", + "TagResource", + "UntagResource", + "UpdateACL", + "UpdateCluster", + "UpdateMultiRegionCluster", + "UpdateParameterGroup", + "UpdateSubnetGroup", + "UpdateUser" + ] + }, + "mq": { + "protocol": "rest-json", + "servedOps": [ + "CreateBroker", + "CreateConfiguration", + "CreateTags", + "CreateUser", + "DeleteBroker", + "DeleteConfiguration", + "DeleteTags", + "DeleteUser", + "DescribeBroker", + "DescribeBrokerEngineTypes", + "DescribeBrokerInstanceOptions", + "DescribeConfiguration", + "DescribeConfigurationRevision", + "DescribeUser", + "ListBrokers", + "ListConfigurationRevisions", + "ListConfigurations", + "ListTags", + "ListUsers", + "Promote", + "RebootBroker", + "UpdateBroker", + "UpdateConfiguration", + "UpdateUser" + ] + }, + "mwaa": { + "protocol": "rest-json", + "servedOps": [ + "CreateCliToken", + "CreateDag", + "CreateDagRun", + "CreateEnvironment", + "CreateVariables", + "CreateWebLoginToken", + "DeleteDag", + "DeleteDagRun", + "DeleteEnvironment", + "DeleteVariables", + "DescribeClusters", + "GetDag", + "GetDagRun", + "GetEnvironment", + "GetEnvironmentConfig", + "GetEnvironmentLogs", + "GetEnvironmentStatus", + "GetVariables", + "InvokeRestApi", + "ListDagRuns", + "ListDags", + "ListEnvironments", + "ListTagsForResource", + "ListVariables", + "PauseDag", + "PublishMetrics", + "RestartEnvironment", + "StartEnvironment", + "StopEnvironment", + "TagResource", + "UntagResource", + "UpdateEnvironment", + "UpdateVariables" + ] + }, + "neptune": { + "protocol": "query", + "servedOps": [ + "AddRoleToDBCluster", + "AddSourceIdentifierToSubscription", + "AddTagsToResource", + "ApplyPendingMaintenanceAction", + "CopyDBClusterParameterGroup", + "CopyDBClusterSnapshot", + "CopyDBParameterGroup", + "CreateDBCluster", + "CreateDBClusterEndpoint", + "CreateDBClusterParameterGroup", + "CreateDBClusterSnapshot", + "CreateDBInstance", + "CreateDBParameterGroup", + "CreateDBSubnetGroup", + "CreateEventSubscription", + "CreateGlobalCluster", + "DeleteDBCluster", + "DeleteDBClusterEndpoint", + "DeleteDBClusterParameterGroup", + "DeleteDBClusterSnapshot", + "DeleteDBInstance", + "DeleteDBParameterGroup", + "DeleteDBSubnetGroup", + "DeleteEventSubscription", + "DeleteGlobalCluster", + "DescribeCertificates", + "DescribeDBClusterEndpoints", + "DescribeDBClusterParameterGroups", + "DescribeDBClusterParameters", + "DescribeDBClusterSnapshotAttributes", + "DescribeDBClusterSnapshots", + "DescribeDBClusters", + "DescribeDBEngineVersions", + "DescribeDBInstances", + "DescribeDBParameterGroups", + "DescribeDBParameters", + "DescribeDBSubnetGroups", + "DescribeEngineDefaultClusterParameters", + "DescribeEngineDefaultParameters", + "DescribeEventCategories", + "DescribeEventSubscriptions", + "DescribeEvents", + "DescribeGlobalClusters", + "DescribeOrderableDBInstanceOptions", + "DescribePendingMaintenanceActions", + "DescribeValidDBInstanceModifications", + "FailoverDBCluster", + "FailoverGlobalCluster", + "ListTagsForResource", + "ModifyDBCluster", + "ModifyDBClusterEndpoint", + "ModifyDBClusterParameterGroup", + "ModifyDBClusterSnapshotAttribute", + "ModifyDBInstance", + "ModifyDBParameterGroup", + "ModifyDBSubnetGroup", + "ModifyEventSubscription", + "ModifyGlobalCluster", + "PromoteReadReplicaDBCluster", + "RebootDBInstance", + "RemoveFromGlobalCluster", + "RemoveRoleFromDBCluster", + "RemoveSourceIdentifierFromSubscription", + "RemoveTagsFromResource", + "ResetDBClusterParameterGroup", + "ResetDBParameterGroup", + "RestoreDBClusterFromSnapshot", + "RestoreDBClusterToPointInTime", + "StartDBCluster", + "StopDBCluster", + "SwitchoverGlobalCluster" + ] + }, + "networkfirewall": { + "protocol": "json-1.0", + "servedOps": [ + "CreateContainerAssociation", + "CreateFirewall", + "CreateFirewallPolicy", + "CreateProxy", + "CreateProxyConfiguration", + "CreateProxyRuleGroup", + "CreateProxyRules", + "CreateRuleGroup", + "CreateTLSInspectionConfiguration", + "CreateVpcEndpointAssociation", + "DeleteContainerAssociation", + "DeleteFirewall", + "DeleteFirewallPolicy", + "DeleteNetworkFirewallTransitGatewayAttachment", + "DeleteProxy", + "DeleteProxyConfiguration", + "DeleteProxyRuleGroup", + "DeleteProxyRules", + "DeleteResourcePolicy", + "DeleteRuleGroup", + "DeleteTLSInspectionConfiguration", + "DeleteVpcEndpointAssociation", + "DescribeContainerAssociation", + "DescribeFirewall", + "DescribeFirewallMetadata", + "DescribeFirewallPolicy", + "DescribeFlowOperation", + "DescribeLoggingConfiguration", + "DescribeProxy", + "DescribeProxyConfiguration", + "DescribeProxyRule", + "DescribeProxyRuleGroup", + "DescribeResourcePolicy", + "DescribeRuleGroup", + "DescribeRuleGroupMetadata", + "DescribeRuleGroupSummary", + "DescribeTLSInspectionConfiguration", + "DescribeVpcEndpointAssociation", + "GetAnalysisReportResults", + "ListAnalysisReports", + "ListContainerAssociations", + "ListFirewallPolicies", + "ListFirewalls", + "ListFlowOperationResults", + "ListFlowOperations", + "ListProxies", + "ListProxyConfigurations", + "ListProxyRuleGroups", + "ListRuleGroups", + "ListTLSInspectionConfigurations", + "ListTagsForResource", + "ListVpcEndpointAssociations", + "PutResourcePolicy", + "TagResource", + "UntagResource", + "UpdateAvailabilityZoneChangeProtection", + "UpdateContainerAssociation", + "UpdateFirewallAnalysisSettings", + "UpdateFirewallDeleteProtection", + "UpdateFirewallDescription", + "UpdateFirewallEncryptionConfiguration", + "UpdateFirewallPolicy", + "UpdateFirewallPolicyChangeProtection", + "UpdateLoggingConfiguration", + "UpdateProxy", + "UpdateProxyConfiguration", + "UpdateProxyRule", + "UpdateProxyRuleGroupPriorities", + "UpdateProxyRulePriorities", + "UpdateProxySettings", + "UpdateRuleGroup", + "UpdateSubnetChangeProtection", + "UpdateTLSInspectionConfiguration" + ] + }, + "networkmanager": { + "protocol": "rest-json", + "servedOps": [ + "CreateConnectAttachment", + "CreateConnectPeer", + "CreateConnection", + "CreateCoreNetwork", + "CreateCoreNetworkPrefixListAssociation", + "CreateDevice", + "CreateDirectConnectGatewayAttachment", + "CreateGlobalNetwork", + "CreateLink", + "CreateSite", + "CreateSiteToSiteVpnAttachment", + "CreateTransitGatewayPeering", + "CreateTransitGatewayRouteTableAttachment", + "CreateVpcAttachment", + "DeleteAttachment", + "DeleteConnectPeer", + "DeleteConnection", + "DeleteCoreNetwork", + "DeleteCoreNetworkPolicyVersion", + "DeleteCoreNetworkPrefixListAssociation", + "DeleteDevice", + "DeleteGlobalNetwork", + "DeleteLink", + "DeletePeering", + "DeleteResourcePolicy", + "DeleteSite", + "DeregisterTransitGateway", + "DescribeGlobalNetworks", + "GetConnectAttachment", + "GetConnectPeer", + "GetConnectPeerAssociations", + "GetConnections", + "GetCoreNetwork", + "GetCoreNetworkChangeEvents", + "GetCoreNetworkChangeSet", + "GetCoreNetworkPolicy", + "GetCustomerGatewayAssociations", + "GetDevices", + "GetDirectConnectGatewayAttachment", + "GetLinkAssociations", + "GetLinks", + "GetNetworkResourceCounts", + "GetNetworkResourceRelationships", + "GetNetworkResources", + "GetNetworkRoutes", + "GetNetworkTelemetry", + "GetResourcePolicy", + "GetRouteAnalysis", + "GetSiteToSiteVpnAttachment", + "GetSites", + "GetTransitGatewayConnectPeerAssociations", + "GetTransitGatewayPeering", + "GetTransitGatewayRegistrations", + "GetTransitGatewayRouteTableAttachment", + "GetVpcAttachment", + "ListAttachmentRoutingPolicyAssociations", + "ListAttachments", + "ListConnectPeers", + "ListCoreNetworkPolicyVersions", + "ListCoreNetworkPrefixListAssociations", + "ListCoreNetworkRoutingInformation", + "ListCoreNetworks", + "ListOrganizationServiceAccessStatus", + "ListPeerings", + "ListTagsForResource", + "PutAttachmentRoutingPolicyLabel", + "PutCoreNetworkPolicy", + "PutResourcePolicy", + "RegisterTransitGateway", + "TagResource", + "UntagResource", + "UpdateConnection", + "UpdateCoreNetwork", + "UpdateDevice", + "UpdateDirectConnectGatewayAttachment", + "UpdateGlobalNetwork", + "UpdateLink", + "UpdateNetworkResourceMetadata", + "UpdateSite", + "UpdateVpcAttachment" + ] + }, + "omics": { + "protocol": "rest-json", + "servedOps": [ + "CreateAnnotationStore", + "CreateAnnotationStoreVersion", + "CreateConfiguration", + "CreateMultipartReadSetUpload", + "CreateReferenceStore", + "CreateRunCache", + "CreateRunGroup", + "CreateSequenceStore", + "CreateShare", + "CreateVariantStore", + "CreateWorkflow", + "CreateWorkflowVersion", + "DeleteAnnotationStore", + "DeleteAnnotationStoreVersions", + "DeleteBatch", + "DeleteConfiguration", + "DeleteReference", + "DeleteReferenceStore", + "DeleteRun", + "DeleteRunBatch", + "DeleteRunCache", + "DeleteRunGroup", + "DeleteS3AccessPolicy", + "DeleteSequenceStore", + "DeleteShare", + "DeleteVariantStore", + "DeleteWorkflow", + "DeleteWorkflowVersion", + "GetAnnotationImportJob", + "GetAnnotationStore", + "GetAnnotationStoreVersion", + "GetBatch", + "GetConfiguration", + "GetReadSet", + "GetReadSetActivationJob", + "GetReadSetExportJob", + "GetReadSetImportJob", + "GetReadSetMetadata", + "GetReference", + "GetReferenceImportJob", + "GetReferenceMetadata", + "GetReferenceStore", + "GetRun", + "GetRunCache", + "GetRunGroup", + "GetRunTask", + "GetS3AccessPolicy", + "GetSequenceStore", + "GetShare", + "GetVariantImportJob", + "GetVariantStore", + "GetWorkflow", + "GetWorkflowVersion", + "ListAnnotationImportJobs", + "ListAnnotationStoreVersions", + "ListAnnotationStores", + "ListBatch", + "ListConfigurations", + "ListMultipartReadSetUploads", + "ListReadSetActivationJobs", + "ListReadSetExportJobs", + "ListReadSetImportJobs", + "ListReadSetUploadParts", + "ListReadSets", + "ListReferenceImportJobs", + "ListReferenceStores", + "ListReferences", + "ListRunCaches", + "ListRunGroups", + "ListRunTasks", + "ListRuns", + "ListRunsInBatch", + "ListSequenceStores", + "ListShares", + "ListTagsForResource", + "ListVariantImportJobs", + "ListVariantStores", + "ListWorkflowVersions", + "ListWorkflows", + "PutS3AccessPolicy", + "TagResource", + "UntagResource", + "UpdateAnnotationStore", + "UpdateAnnotationStoreVersion", + "UpdateRunCache", + "UpdateRunGroup", + "UpdateSequenceStore", + "UpdateVariantStore", + "UpdateWorkflow", + "UpdateWorkflowVersion" + ] + }, + "opensearch": { + "protocol": "rest-json", + "servedOps": [ + "AcceptInboundConnection", + "AddDataSource", + "AddDirectQueryDataSource", + "AddTags", + "AssociatePackage", + "AssociatePackages", + "AuthorizeVpcEndpointAccess", + "CancelDomainConfigChange", + "CancelServiceSoftwareUpdate", + "CreateApplication", + "CreateDomain", + "CreateIndex", + "CreateOutboundConnection", + "CreatePackage", + "CreateVpcEndpoint", + "DeleteApplication", + "DeleteDataSource", + "DeleteDirectQueryDataSource", + "DeleteDomain", + "DeleteInboundConnection", + "DeleteIndex", + "DeleteOutboundConnection", + "DeletePackage", + "DeleteVpcEndpoint", + "DeregisterCapability", + "DescribeDomain", + "DescribeDomainAutoTunes", + "DescribeDomainChangeProgress", + "DescribeDomainConfig", + "DescribeDomainHealth", + "DescribeDomainNodes", + "DescribeDomains", + "DescribeDryRunProgress", + "DescribeInboundConnections", + "DescribeInsightDetails", + "DescribeInstanceTypeLimits", + "DescribeOutboundConnections", + "DescribePackages", + "DescribeReservedInstanceOfferings", + "DescribeReservedInstances", + "DescribeVpcEndpoints", + "DissociatePackage", + "DissociatePackages", + "GetApplication", + "GetCapability", + "GetCompatibleVersions", + "GetDataSource", + "GetDefaultApplicationSetting", + "GetDirectQueryDataSource", + "GetDomainMaintenanceStatus", + "GetIndex", + "GetPackageVersionHistory", + "GetUpgradeHistory", + "GetUpgradeStatus", + "ListApplications", + "ListDataSources", + "ListDirectQueryDataSources", + "ListDomainMaintenances", + "ListDomainNames", + "ListDomainsForPackage", + "ListInsights", + "ListInstanceTypeDetails", + "ListPackagesForDomain", + "ListScheduledActions", + "ListTags", + "ListVersions", + "ListVpcEndpointAccess", + "ListVpcEndpoints", + "ListVpcEndpointsForDomain", + "PurchaseReservedInstanceOffering", + "PutDefaultApplicationSetting", + "RegisterCapability", + "RejectInboundConnection", + "RemoveTags", + "RevokeVpcEndpointAccess", + "StartDomainMaintenance", + "StartServiceSoftwareUpdate", + "UpdateApplication", + "UpdateDataSource", + "UpdateDirectQueryDataSource", + "UpdateDomainConfig", + "UpdateIndex", + "UpdatePackage", + "UpdatePackageScope", + "UpdateScheduledAction", + "UpdateVpcEndpoint", + "UpgradeDomain" + ] + }, + "opensearchserverless": { + "protocol": "json-1.0", + "servedOps": [ + "BatchGetCollection", + "BatchGetCollectionGroup", + "BatchGetEffectiveLifecyclePolicy", + "BatchGetLifecyclePolicy", + "BatchGetVpcEndpoint", + "CreateAccessPolicy", + "CreateCollection", + "CreateCollectionGroup", + "CreateIndex", + "CreateLifecyclePolicy", + "CreateSecurityConfig", + "CreateSecurityPolicy", + "CreateVpcEndpoint", + "DeleteAccessPolicy", + "DeleteCollection", + "DeleteCollectionGroup", + "DeleteIndex", + "DeleteLifecyclePolicy", + "DeleteSecurityConfig", + "DeleteSecurityPolicy", + "DeleteVpcEndpoint", + "GetAccessPolicy", + "GetAccountSettings", + "GetIndex", + "GetPoliciesStats", + "GetSecurityConfig", + "GetSecurityPolicy", + "ListAccessPolicies", + "ListCollectionGroups", + "ListCollections", + "ListLifecyclePolicies", + "ListSecurityConfigs", + "ListSecurityPolicies", + "ListTagsForResource", + "ListVpcEndpoints", + "TagResource", + "UntagResource", + "UpdateAccessPolicy", + "UpdateAccountSettings", + "UpdateCollection", + "UpdateCollectionGroup", + "UpdateIndex", + "UpdateLifecyclePolicy", + "UpdateSecurityConfig", + "UpdateSecurityPolicy", + "UpdateVpcEndpoint" + ] + }, + "organizations": { + "protocol": "json-1.1", + "servedOps": [ + "AcceptHandshake", + "AttachPolicy", + "CancelHandshake", + "CloseAccount", + "CreateAccount", + "CreateGovCloudAccount", + "CreateOrganization", + "CreateOrganizationalUnit", + "CreatePolicy", + "DeclineHandshake", + "DeleteOrganization", + "DeleteOrganizationalUnit", + "DeletePolicy", + "DeleteResourcePolicy", + "DeregisterDelegatedAdministrator", + "DescribeAccount", + "DescribeCreateAccountStatus", + "DescribeEffectivePolicy", + "DescribeHandshake", + "DescribeOrganization", + "DescribeOrganizationalUnit", + "DescribePolicy", + "DescribeResourcePolicy", + "DescribeResponsibilityTransfer", + "DetachPolicy", + "DisableAWSServiceAccess", + "DisablePolicyType", + "EnableAWSServiceAccess", + "EnableAllFeatures", + "EnablePolicyType", + "InviteAccountToOrganization", + "LeaveOrganization", + "ListAWSServiceAccessForOrganization", + "ListAccounts", + "ListAccountsForParent", + "ListAccountsWithInvalidEffectivePolicy", + "ListChildren", + "ListCreateAccountStatus", + "ListDelegatedAdministrators", + "ListDelegatedServicesForAccount", + "ListEffectivePolicyValidationErrors", + "ListHandshakesForAccount", + "ListHandshakesForOrganization", + "ListInboundResponsibilityTransfers", + "ListOrganizationalUnitsForParent", + "ListOutboundResponsibilityTransfers", + "ListParents", + "ListPolicies", + "ListPoliciesForTarget", + "ListRoots", + "ListTagsForResource", + "ListTargetsForPolicy", + "MoveAccount", + "PutResourcePolicy", + "RegisterDelegatedAdministrator", + "RemoveAccountFromOrganization", + "TagResource", + "UntagResource", + "UpdateOrganizationalUnit", + "UpdatePolicy", + "UpdateResponsibilityTransfer" + ] + }, + "osis": { + "protocol": "rest-json", + "servedOps": [ + "CreatePipeline", + "CreatePipelineEndpoint", + "DeletePipeline", + "DeletePipelineEndpoint", + "DeleteResourcePolicy", + "GetPipeline", + "GetPipelineBlueprint", + "GetPipelineChangeProgress", + "GetResourcePolicy", + "ListPipelineBlueprints", + "ListPipelineEndpointConnections", + "ListPipelineEndpoints", + "ListPipelines", + "ListTagsForResource", + "PutResourcePolicy", + "TagResource", + "UntagResource", + "UpdatePipeline" + ] + }, + "paymentcryptography": { + "protocol": "json-1.0", + "servedOps": [ + "CreateAlias", + "CreateKey", + "DeleteAlias", + "DeleteKey", + "DeleteResourcePolicy", + "GetAlias", + "GetCertificateSigningRequest", + "GetDefaultKeyReplicationRegions", + "GetKey", + "GetMpaTeamAssociation", + "GetParametersForExport", + "GetParametersForImport", + "GetPublicKeyCertificate", + "GetResourcePolicy", + "ListAliases", + "ListKeys", + "ListTagsForResource", + "PutResourcePolicy", + "TagResource", + "UntagResource", + "UpdateAlias" + ] + }, + "personalize": { + "protocol": "json-1.1", + "servedOps": [ + "CreateBatchInferenceJob", + "CreateBatchSegmentJob", + "CreateCampaign", + "CreateDataDeletionJob", + "CreateDataset", + "CreateDatasetExportJob", + "CreateDatasetGroup", + "CreateDatasetImportJob", + "CreateEventTracker", + "CreateFilter", + "CreateMetricAttribution", + "CreateRecommender", + "CreateSchema", + "CreateSolution", + "CreateSolutionVersion", + "DeleteCampaign", + "DeleteDataset", + "DeleteDatasetGroup", + "DeleteEventTracker", + "DeleteFilter", + "DeleteMetricAttribution", + "DeleteRecommender", + "DeleteSchema", + "DeleteSolution", + "DescribeAlgorithm", + "DescribeBatchInferenceJob", + "DescribeBatchSegmentJob", + "DescribeCampaign", + "DescribeDataDeletionJob", + "DescribeDataset", + "DescribeDatasetExportJob", + "DescribeDatasetGroup", + "DescribeDatasetImportJob", + "DescribeEventTracker", + "DescribeFeatureTransformation", + "DescribeFilter", + "DescribeMetricAttribution", + "DescribeRecipe", + "DescribeRecommender", + "DescribeSchema", + "DescribeSolution", + "DescribeSolutionVersion", + "GetSolutionMetrics", + "ListBatchInferenceJobs", + "ListBatchSegmentJobs", + "ListCampaigns", + "ListDataDeletionJobs", + "ListDatasetExportJobs", + "ListDatasetGroups", + "ListDatasetImportJobs", + "ListDatasets", + "ListEventTrackers", + "ListFilters", + "ListMetricAttributionMetrics", + "ListMetricAttributions", + "ListRecipes", + "ListRecommenders", + "ListSchemas", + "ListSolutionVersions", + "ListSolutions", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateCampaign", + "UpdateDataset", + "UpdateMetricAttribution", + "UpdateRecommender", + "UpdateSolution" + ] + }, + "personalizeevents": { + "protocol": "rest-json", + "servedOps": [ + "PutActionInteractions", + "PutActions", + "PutEvents", + "PutItems", + "PutUsers" + ] + }, + "personalizeruntime": { + "protocol": "rest-json", + "servedOps": [ + "GetActionRecommendations", + "GetPersonalizedRanking", + "GetRecommendations" + ] + }, + "pinpoint": { + "protocol": "rest-json", + "servedOps": [ + "CreateApp", + "CreateCampaign", + "CreateEmailTemplate", + "CreateExportJob", + "CreateImportJob", + "CreateInAppTemplate", + "CreateJourney", + "CreatePushTemplate", + "CreateRecommenderConfiguration", + "CreateSegment", + "CreateSmsTemplate", + "CreateVoiceTemplate", + "DeleteAdmChannel", + "DeleteApnsChannel", + "DeleteApnsSandboxChannel", + "DeleteApnsVoipChannel", + "DeleteApnsVoipSandboxChannel", + "DeleteApp", + "DeleteBaiduChannel", + "DeleteCampaign", + "DeleteEmailChannel", + "DeleteEmailTemplate", + "DeleteEndpoint", + "DeleteEventStream", + "DeleteGcmChannel", + "DeleteInAppTemplate", + "DeleteJourney", + "DeletePushTemplate", + "DeleteRecommenderConfiguration", + "DeleteSegment", + "DeleteSmsChannel", + "DeleteSmsTemplate", + "DeleteUserEndpoints", + "DeleteVoiceChannel", + "DeleteVoiceTemplate", + "GetAdmChannel", + "GetApnsChannel", + "GetApnsSandboxChannel", + "GetApnsVoipChannel", + "GetApnsVoipSandboxChannel", + "GetApp", + "GetApplicationDateRangeKpi", + "GetApplicationSettings", + "GetApps", + "GetBaiduChannel", + "GetCampaign", + "GetCampaignActivities", + "GetCampaignDateRangeKpi", + "GetCampaignVersion", + "GetCampaignVersions", + "GetCampaigns", + "GetChannels", + "GetEmailChannel", + "GetEmailTemplate", + "GetEndpoint", + "GetEventStream", + "GetExportJob", + "GetExportJobs", + "GetGcmChannel", + "GetImportJob", + "GetImportJobs", + "GetInAppMessages", + "GetInAppTemplate", + "GetJourney", + "GetJourneyDateRangeKpi", + "GetJourneyExecutionActivityMetrics", + "GetJourneyExecutionMetrics", + "GetJourneyRunExecutionActivityMetrics", + "GetJourneyRunExecutionMetrics", + "GetJourneyRuns", + "GetPushTemplate", + "GetRecommenderConfiguration", + "GetRecommenderConfigurations", + "GetSegment", + "GetSegmentExportJobs", + "GetSegmentImportJobs", + "GetSegmentVersion", + "GetSegmentVersions", + "GetSegments", + "GetSmsChannel", + "GetSmsTemplate", + "GetUserEndpoints", + "GetVoiceChannel", + "GetVoiceTemplate", + "ListJourneys", + "ListTagsForResource", + "ListTemplateVersions", + "ListTemplates", + "PhoneNumberValidate", + "PutEventStream", + "PutEvents", + "RemoveAttributes", + "SendMessages", + "SendOTPMessage", + "SendUsersMessages", + "TagResource", + "UntagResource", + "UpdateAdmChannel", + "UpdateApnsChannel", + "UpdateApnsSandboxChannel", + "UpdateApnsVoipChannel", + "UpdateApnsVoipSandboxChannel", + "UpdateApplicationSettings", + "UpdateBaiduChannel", + "UpdateCampaign", + "UpdateEmailChannel", + "UpdateEmailTemplate", + "UpdateEndpoint", + "UpdateEndpointsBatch", + "UpdateGcmChannel", + "UpdateInAppTemplate", + "UpdateJourney", + "UpdateJourneyState", + "UpdatePushTemplate", + "UpdateRecommenderConfiguration", + "UpdateSegment", + "UpdateSmsChannel", + "UpdateSmsTemplate", + "UpdateTemplateActiveVersion", + "UpdateVoiceChannel", + "UpdateVoiceTemplate", + "VerifyOTPMessage" + ] + }, + "pipes": { + "protocol": "", + "servedOps": [ + "CreatePipe", + "DeletePipe", + "DescribePipe", + "DescribePipeHealth", + "DescribePipeTargets", + "DisablePipe", + "EnablePipe", + "GetPipeConfiguration", + "GetPipeMetrics", + "GetPipeStatistics", + "ListPipeEvents", + "ListPipeExecutions", + "ListPipeTargets", + "ListPipes", + "ListTagsForResource", + "PutPipeConfiguration", + "StartPipe", + "StopPipe", + "TagResource", + "TestPipe", + "UntagResource", + "UpdatePipe", + "ValidatePipeParameters" + ] + }, + "polly": { + "protocol": "rest-json", + "servedOps": [ + "DeleteLexicon", + "DescribeVoices", + "GetLexicon", + "GetSpeechSynthesisTask", + "ListLexicons", + "ListSpeechSynthesisTasks", + "PutLexicon" + ] + }, + "qapps": { + "protocol": "rest-json", + "servedOps": [ + "CreateLibraryItem", + "CreatePresignedUrl", + "CreateQApp", + "DeleteLibraryItem", + "DeleteQApp", + "DescribeQAppPermissions", + "GetLibraryItem", + "GetQApp", + "GetQAppSession", + "GetQAppSessionMetadata", + "ListCategories", + "ListLibraryItems", + "ListQAppSessionData", + "ListQApps", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateLibraryItem", + "UpdateLibraryItemMetadata", + "UpdateQApp", + "UpdateQAppPermissions", + "UpdateQAppSession", + "UpdateQAppSessionMetadata" + ] + }, + "qbusiness": { + "protocol": "rest-json", + "servedOps": [ + "CreateAnonymousWebExperienceUrl", + "CreateApplication", + "CreateChatResponseConfiguration", + "CreateDataAccessor", + "CreateDataSource", + "CreateIndex", + "CreatePlugin", + "CreateRetriever", + "CreateSubscription", + "CreateUser", + "CreateWebExperience", + "DeleteApplication", + "DeleteAttachment", + "DeleteChatControlsConfiguration", + "DeleteChatResponseConfiguration", + "DeleteConversation", + "DeleteDataAccessor", + "DeleteDataSource", + "DeleteGroup", + "DeleteIndex", + "DeletePlugin", + "DeleteRetriever", + "DeleteUser", + "DeleteWebExperience", + "GetApplication", + "GetChatControlsConfiguration", + "GetChatResponseConfiguration", + "GetDataAccessor", + "GetDataSource", + "GetDocumentContent", + "GetGroup", + "GetIndex", + "GetMedia", + "GetPlugin", + "GetPolicy", + "GetRetriever", + "GetUser", + "GetWebExperience", + "ListApplications", + "ListAttachments", + "ListChatResponseConfigurations", + "ListConversations", + "ListDataAccessors", + "ListDataSourceSyncJobs", + "ListDataSources", + "ListDocuments", + "ListGroups", + "ListIndices", + "ListMessages", + "ListPluginActions", + "ListPluginTypeActions", + "ListPluginTypeMetadata", + "ListPlugins", + "ListRetrievers", + "ListSubscriptions", + "ListTagsForResource", + "ListWebExperiences", + "PutFeedback", + "PutGroup", + "TagResource", + "UntagResource", + "UpdateApplication", + "UpdateChatControlsConfiguration", + "UpdateChatResponseConfiguration", + "UpdateDataAccessor", + "UpdateDataSource", + "UpdateIndex", + "UpdatePlugin", + "UpdateRetriever", + "UpdateSubscription", + "UpdateUser", + "UpdateWebExperience" + ] + }, + "quicksight": { + "protocol": "rest-json", + "servedOps": [ + "CreateAccountCustomization", + "CreateAccountSubscription", + "CreateActionConnector", + "CreateAgent", + "CreateAnalysis", + "CreateApprovalPolicy", + "CreateBrand", + "CreateCustomPermissions", + "CreateDashboard", + "CreateDataSet", + "CreateDataSource", + "CreateDlpSetting", + "CreateFlow", + "CreateFolder", + "CreateFolderMembership", + "CreateGroup", + "CreateGroupMembership", + "CreateIAMPolicyAssignment", + "CreateIngestion", + "CreateKnowledgeBase", + "CreateLimitsProfile", + "CreateNamespace", + "CreateOAuthClientApplication", + "CreateRefreshSchedule", + "CreateRoleMembership", + "CreateSpace", + "CreateTemplate", + "CreateTemplateAlias", + "CreateTheme", + "CreateThemeAlias", + "CreateTopic", + "CreateTopicRefreshSchedule", + "CreateTopicV2", + "CreateVPCConnection", + "DeleteAccountCustomPermission", + "DeleteAccountCustomization", + "DeleteAccountSubscription", + "DeleteActionConnector", + "DeleteAgent", + "DeleteAnalysis", + "DeleteApp", + "DeleteApprovalPolicy", + "DeleteBrand", + "DeleteBrandAssignment", + "DeleteCustomPermissions", + "DeleteDashboard", + "DeleteDataSet", + "DeleteDataSetRefreshProperties", + "DeleteDataSource", + "DeleteDefaultQBusinessApplication", + "DeleteDlpSetting", + "DeleteFlow", + "DeleteFolder", + "DeleteFolderMembership", + "DeleteGroup", + "DeleteGroupMembership", + "DeleteIAMPolicyAssignment", + "DeleteIdentityPropagationConfig", + "DeleteKnowledgeBase", + "DeleteLimitsProfile", + "DeleteNamespace", + "DeleteOAuthClientApplication", + "DeleteRefreshSchedule", + "DeleteRoleCustomPermission", + "DeleteRoleMembership", + "DeleteSpace", + "DeleteTemplate", + "DeleteTemplateAlias", + "DeleteTheme", + "DeleteThemeAlias", + "DeleteTopic", + "DeleteTopicRefreshSchedule", + "DeleteTopicV2", + "DeleteUser", + "DeleteUserByPrincipalId", + "DeleteUserCustomPermission", + "DeleteVPCConnection", + "DescribeAccountCustomPermission", + "DescribeAccountCustomization", + "DescribeAccountSettings", + "DescribeAccountSubscription", + "DescribeActionConnector", + "DescribeActionConnectorPermissions", + "DescribeAgent", + "DescribeAgentPermissions", + "DescribeAnalysis", + "DescribeAnalysisDefinition", + "DescribeAnalysisPermissions", + "DescribeApp", + "DescribeAppPermissions", + "DescribeApprovalPolicy", + "DescribeAssetBundleExportJob", + "DescribeAssetBundleImportJob", + "DescribeAutomationJob", + "DescribeBrand", + "DescribeBrandAssignment", + "DescribeBrandPublishedVersion", + "DescribeCustomPermissions", + "DescribeDashboard", + "DescribeDashboardDefinition", + "DescribeDashboardPermissions", + "DescribeDashboardSnapshotJob", + "DescribeDashboardSnapshotJobResult", + "DescribeDashboardsQAConfiguration", + "DescribeDataSet", + "DescribeDataSetPermissions", + "DescribeDataSetRefreshProperties", + "DescribeDataSource", + "DescribeDataSourcePermissions", + "DescribeDefaultQBusinessApplication", + "DescribeDlpSetting", + "DescribeFlow", + "DescribeFolder", + "DescribeFolderPermissions", + "DescribeFolderResolvedPermissions", + "DescribeGroup", + "DescribeGroupMembership", + "DescribeIAMPolicyAssignment", + "DescribeIngestion", + "DescribeIpRestriction", + "DescribeKeyRegistration", + "DescribeKnowledgeBase", + "DescribeKnowledgeBasePermissions", + "DescribeLimitsProfile", + "DescribeNamespace", + "DescribeOAuthClientApplication", + "DescribeQPersonalizationConfiguration", + "DescribeQuickSightQSearchConfiguration", + "DescribeRefreshSchedule", + "DescribeRoleCustomPermission", + "DescribeSelfUpgradeConfiguration", + "DescribeSpace", + "DescribeSpacePermissions", + "DescribeTemplate", + "DescribeTemplateAlias", + "DescribeTemplateDefinition", + "DescribeTemplatePermissions", + "DescribeTheme", + "DescribeThemeAlias", + "DescribeThemePermissions", + "DescribeTopic", + "DescribeTopicPermissions", + "DescribeTopicPermissionsV2", + "DescribeTopicRefresh", + "DescribeTopicRefreshSchedule", + "DescribeTopicV2", + "DescribeUser", + "DescribeVPCConnection", + "GetDashboardEmbedUrl", + "GetFlowMetadata", + "GetFlowPermissions", + "GetIdentityContext", + "GetSessionEmbedUrl", + "ListActionConnectors", + "ListAgents", + "ListAnalyses", + "ListApprovalPolicies", + "ListApps", + "ListAssetBundleExportJobs", + "ListAssetBundleImportJobs", + "ListBrands", + "ListCustomPermissions", + "ListDashboardVersions", + "ListDashboards", + "ListDataSets", + "ListDataSources", + "ListDlpSettings", + "ListFlows", + "ListFolderMembers", + "ListFolders", + "ListFoldersForResource", + "ListGroupMemberships", + "ListGroups", + "ListIAMPolicyAssignments", + "ListIAMPolicyAssignmentsForUser", + "ListIdentityPropagationConfigs", + "ListIngestions", + "ListKnowledgeBases", + "ListLimitsProfiles", + "ListNamespaces", + "ListOAuthClientApplications", + "ListRefreshSchedules", + "ListRoleMemberships", + "ListSelfUpgrades", + "ListSpaceResources", + "ListSpaces", + "ListTagsForResource", + "ListTemplateAliases", + "ListTemplateVersions", + "ListTemplates", + "ListThemeAliases", + "ListThemeVersions", + "ListThemes", + "ListTopicRefreshSchedules", + "ListTopicReviewedAnswers", + "ListTopics", + "ListTopicsV2", + "ListUserGroups", + "ListUsers", + "ListUsersIndexCapacity", + "ListVPCConnections", + "PutDataSetRefreshProperties", + "RegisterUser", + "TagResource", + "UntagResource", + "UpdateAccountCustomPermission", + "UpdateAccountCustomization", + "UpdateAccountSettings", + "UpdateActionConnector", + "UpdateActionConnectorPermissions", + "UpdateAgent", + "UpdateAgentPermissions", + "UpdateAnalysis", + "UpdateAnalysisPermissions", + "UpdateAppPermissions", + "UpdateApplicationWithTokenExchangeGrant", + "UpdateApprovalPolicy", + "UpdateBrand", + "UpdateBrandAssignment", + "UpdateBrandPublishedVersion", + "UpdateCustomPermissions", + "UpdateDashboard", + "UpdateDashboardLinks", + "UpdateDashboardPermissions", + "UpdateDashboardPublishedVersion", + "UpdateDashboardsQAConfiguration", + "UpdateDataSet", + "UpdateDataSetPermissions", + "UpdateDataSource", + "UpdateDataSourcePermissions", + "UpdateDefaultQBusinessApplication", + "UpdateDlpSetting", + "UpdateFlow", + "UpdateFlowPermissions", + "UpdateFolder", + "UpdateFolderPermissions", + "UpdateGroup", + "UpdateIAMPolicyAssignment", + "UpdateIdentityPropagationConfig", + "UpdateIpRestriction", + "UpdateKeyRegistration", + "UpdateKnowledgeBase", + "UpdateKnowledgeBasePermissions", + "UpdateLimitsProfile", + "UpdateOAuthClientApplication", + "UpdatePublicSharingSettings", + "UpdateQPersonalizationConfiguration", + "UpdateQuickSightQSearchConfiguration", + "UpdateRefreshSchedule", + "UpdateRoleCustomPermission", + "UpdateSPICECapacityConfiguration", + "UpdateSelfUpgrade", + "UpdateSelfUpgradeConfiguration", + "UpdateSpace", + "UpdateSpacePermissions", + "UpdateSpaceResources", + "UpdateTemplate", + "UpdateTemplateAlias", + "UpdateTemplatePermissions", + "UpdateTheme", + "UpdateThemeAlias", + "UpdateThemePermissions", + "UpdateTopic", + "UpdateTopicPermissions", + "UpdateTopicPermissionsV2", + "UpdateTopicRefreshSchedule", + "UpdateTopicV2", + "UpdateUser", + "UpdateUserCustomPermission", + "UpdateVPCConnection" + ] + }, + "ram": { + "protocol": "rest-json", + "servedOps": [ + "AcceptResourceShareInvitation", + "AssociateResourceShare", + "AssociateResourceSharePermission", + "CreatePermission", + "CreateResourceShare", + "DeletePermission", + "DeletePermissionVersion", + "DeleteResourceShare", + "DisassociateResourceShare", + "DisassociateResourceSharePermission", + "EnableSharingWithAwsOrganization", + "GetPermission", + "GetResourcePolicies", + "GetResourceShareAssociations", + "GetResourceShareInvitations", + "GetResourceShares", + "ListPendingInvitationResources", + "ListPermissionAssociations", + "ListPermissionVersions", + "ListPermissions", + "ListPrincipals", + "ListReplacePermissionAssociationsWork", + "ListResourceSharePermissions", + "ListResourceTypes", + "ListResources", + "ListSourceAssociations", + "PromotePermissionCreatedFromPolicy", + "PromoteResourceShareCreatedFromPolicy", + "RejectResourceShareInvitation", + "ReplacePermissionAssociations", + "SetDefaultPermissionVersion", + "TagResource", + "UntagResource", + "UpdateResourceShare" + ] + }, + "rds": { + "protocol": "query", + "servedOps": [ + "AddTagsToResource", + "ApplyPendingMaintenanceAction", + "CopyDBClusterParameterGroup", + "CopyDBClusterSnapshot", + "CopyDBParameterGroup", + "CopyDBSnapshot", + "CopyOptionGroup", + "CreateDBCluster", + "CreateDBClusterParameterGroup", + "CreateDBClusterSnapshot", + "CreateDBInstance", + "CreateDBParameterGroup", + "CreateDBSnapshot", + "CreateDBSubnetGroup", + "CreateOptionGroup", + "DeleteDBCluster", + "DeleteDBClusterParameterGroup", + "DeleteDBClusterSnapshot", + "DeleteDBInstance", + "DeleteDBParameterGroup", + "DeleteDBSnapshot", + "DeleteDBSubnetGroup", + "DeleteOptionGroup", + "DescribeAccountAttributes", + "DescribeCertificates", + "DescribeDBClusterParameterGroups", + "DescribeDBClusterParameters", + "DescribeDBClusterSnapshots", + "DescribeDBClusters", + "DescribeDBEngineVersions", + "DescribeDBInstances", + "DescribeDBParameterGroups", + "DescribeDBParameters", + "DescribeDBSnapshots", + "DescribeDBSubnetGroups", + "DescribeEngineDefaultClusterParameters", + "DescribeEngineDefaultParameters", + "DescribeEventCategories", + "DescribeEvents", + "DescribeOptionGroupOptions", + "DescribeOptionGroups", + "DescribeOrderableDBInstanceOptions", + "DescribePendingMaintenanceActions", + "DescribeSourceRegions", + "FailoverDBCluster", + "ListTagsForResource", + "ModifyDBCluster", + "ModifyDBClusterParameterGroup", + "ModifyDBInstance", + "ModifyDBParameterGroup", + "ModifyDBSubnetGroup", + "ModifyOptionGroup", + "RebootDBCluster", + "RebootDBInstance", + "RemoveTagsFromResource", + "ResetDBClusterParameterGroup", + "ResetDBParameterGroup", + "StartDBCluster", + "StartDBInstance", + "StopDBCluster", + "StopDBInstance" + ] + }, + "rdsdata": { + "protocol": "rest-json", + "servedOps": [] + }, + "redshift": { + "protocol": "query", + "servedOps": [ + "CopyClusterSnapshot", + "CreateCluster", + "CreateClusterParameterGroup", + "CreateClusterSnapshot", + "CreateClusterSubnetGroup", + "CreateTags", + "DeleteCluster", + "DeleteClusterParameterGroup", + "DeleteClusterSnapshot", + "DeleteClusterSubnetGroup", + "DeleteTags", + "DescribeClusterParameterGroups", + "DescribeClusterParameters", + "DescribeClusterSnapshots", + "DescribeClusterSubnetGroups", + "DescribeClusters", + "DescribeDefaultClusterParameters", + "DescribeLoggingStatus", + "DescribeTags", + "DisableLogging", + "EnableLogging", + "GetClusterCredentials", + "GetClusterCredentialsWithIAM", + "ModifyCluster", + "ModifyClusterParameterGroup", + "ModifyClusterSubnetGroup", + "PauseCluster", + "RebootCluster", + "ResetClusterParameterGroup", + "RestoreFromClusterSnapshot", + "ResumeCluster" + ] + }, + "redshiftdata": { + "protocol": "json-1.1", + "servedOps": [ + "DescribeStatement", + "DescribeTable", + "GetStatementResult", + "GetStatementResultV2", + "ListDatabases", + "ListSchemas", + "ListSessions", + "ListStatements", + "ListTables" + ] + }, + "rekognition": { + "protocol": "json-1.1", + "servedOps": [ + "CreateCollection", + "CreateDataset", + "CreateFaceLivenessSession", + "CreateProject", + "CreateProjectVersion", + "CreateStreamProcessor", + "CreateUser", + "DeleteCollection", + "DeleteDataset", + "DeleteFaces", + "DeleteProject", + "DeleteProjectPolicy", + "DeleteProjectVersion", + "DeleteStreamProcessor", + "DeleteUser", + "DescribeCollection", + "DescribeDataset", + "DescribeProjectVersions", + "DescribeProjects", + "DescribeStreamProcessor", + "GetCelebrityInfo", + "GetCelebrityRecognition", + "GetContentModeration", + "GetFaceDetection", + "GetFaceLivenessSessionResults", + "GetFaceSearch", + "GetLabelDetection", + "GetMediaAnalysisJob", + "GetPersonTracking", + "GetSegmentDetection", + "GetTextDetection", + "ListCollections", + "ListDatasetEntries", + "ListDatasetLabels", + "ListFaces", + "ListMediaAnalysisJobs", + "ListProjectPolicies", + "ListStreamProcessors", + "ListTagsForResource", + "ListUsers", + "PutProjectPolicy", + "TagResource", + "UntagResource", + "UpdateDatasetEntries", + "UpdateStreamProcessor" + ] + }, + "resiliencehub": { + "protocol": "rest-json", + "servedOps": [ + "CreateApp", + "CreateAppVersionAppComponent", + "CreateAppVersionResource", + "CreateRecommendationTemplate", + "CreateResiliencyPolicy", + "DeleteApp", + "DeleteAppAssessment", + "DeleteAppInputSource", + "DeleteAppVersionAppComponent", + "DeleteAppVersionResource", + "DeleteRecommendationTemplate", + "DeleteResiliencyPolicy", + "DescribeApp", + "DescribeAppAssessment", + "DescribeAppVersion", + "DescribeAppVersionAppComponent", + "DescribeAppVersionResource", + "DescribeAppVersionResourcesResolutionStatus", + "DescribeAppVersionTemplate", + "DescribeDraftAppVersionResourcesImportStatus", + "DescribeMetricsExport", + "DescribeResiliencyPolicy", + "DescribeResourceGroupingRecommendationTask", + "ListAlarmRecommendations", + "ListAppAssessmentComplianceDrifts", + "ListAppAssessmentResourceDrifts", + "ListAppAssessments", + "ListAppComponentCompliances", + "ListAppComponentRecommendations", + "ListAppInputSources", + "ListAppVersionAppComponents", + "ListAppVersionResourceMappings", + "ListAppVersionResources", + "ListAppVersions", + "ListApps", + "ListMetrics", + "ListRecommendationTemplates", + "ListResiliencyPolicies", + "ListResourceGroupingRecommendations", + "ListSopRecommendations", + "ListSuggestedResiliencyPolicies", + "ListTagsForResource", + "ListTestRecommendations", + "ListUnsupportedAppVersionResources", + "PutDraftAppVersionTemplate", + "TagResource", + "UntagResource", + "UpdateApp", + "UpdateAppVersion", + "UpdateAppVersionAppComponent", + "UpdateAppVersionResource", + "UpdateResiliencyPolicy" + ] + }, + "resourcegroups": { + "protocol": "rest-json", + "servedOps": [ + "CancelTagSyncTask", + "CreateGroup", + "DeleteGroup", + "GetAccountSettings", + "GetGroup", + "GetGroupConfiguration", + "GetGroupQuery", + "GetTagSyncTask", + "GetTags", + "GroupResources", + "ListGroupResources", + "ListGroupingStatuses", + "ListGroups", + "ListTagSyncTasks", + "PutGroupConfiguration", + "SearchResources", + "StartTagSyncTask", + "UngroupResources", + "Untag", + "UpdateAccountSettings", + "UpdateGroup", + "UpdateGroupQuery" + ] + }, + "resourcegroupstaggingapi": { + "protocol": "json-1.1", + "servedOps": [ + "AssociateTags", + "CreateTagOption", + "DeleteTagOption", + "DescribeReportCreation", + "DisassociateTags", + "GetComplianceDetails", + "GetComplianceSummary", + "GetResourceTags", + "GetResources", + "GetTagKeys", + "GetTagOption", + "GetTagValues", + "ListRequiredTags", + "ListResourcesWithTagFilter", + "ListTagAssociations", + "ListTagOptions", + "ListTaggedResourcesByType", + "SearchResourcesByTags", + "StartReportCreation", + "TagResources", + "UntagResources", + "UpdateTagOption" + ] + }, + "route53": { + "protocol": "rest-xml", + "servedOps": [ + "ActivateKeySigningKey", + "AssociateVPCWithHostedZone", + "ChangeCidrCollection", + "ChangeResourceRecordSets", + "ChangeTagsForResource", + "CreateCidrCollection", + "CreateHealthCheck", + "CreateHostedZone", + "CreateKeySigningKey", + "CreateQueryLoggingConfig", + "CreateReusableDelegationSet", + "CreateTrafficPolicy", + "CreateTrafficPolicyInstance", + "DeactivateKeySigningKey", + "DeleteCidrCollection", + "DeleteHealthCheck", + "DeleteHostedZone", + "DeleteKeySigningKey", + "DeleteQueryLoggingConfig", + "DeleteReusableDelegationSet", + "DeleteTrafficPolicy", + "DeleteTrafficPolicyInstance", + "DisableHostedZoneDNSSEC", + "DisassociateVPCFromHostedZone", + "EnableHostedZoneDNSSEC", + "GetDNSSEC", + "GetHealthCheck", + "GetHealthCheckStatus", + "GetHostedZone", + "GetQueryLoggingConfig", + "GetReusableDelegationSet", + "GetTrafficPolicy", + "GetTrafficPolicyInstance", + "ListCidrBlocks", + "ListCidrCollections", + "ListCidrLocations", + "ListHealthChecks", + "ListHostedZones", + "ListKeySigningKeys", + "ListQueryLoggingConfigs", + "ListResourceRecordSets", + "ListReusableDelegationSets", + "ListTagsForResource", + "ListTrafficPolicies", + "ListTrafficPolicyInstances", + "ListTrafficPolicyInstancesByHostedZone", + "ListTrafficPolicyInstancesByPolicy", + "UpdateHealthCheck", + "UpdateTrafficPolicyInstance" + ] + }, + "route53domains": { + "protocol": "json-1.1", + "servedOps": [ + "DeleteDomain", + "DeleteTagsForDomain", + "GetContactReachabilityStatus", + "GetDomainDetail", + "GetDomainSuggestions", + "GetOperationDetail", + "ListDomains", + "ListOperations", + "ListPrices", + "ListTagsForDomain", + "RegisterDomain", + "UpdateDomainContact", + "UpdateDomainContactPrivacy", + "UpdateDomainNameservers", + "UpdateTagsForDomain" + ] + }, + "route53resolver": { + "protocol": "json-1.1", + "servedOps": [ + "AssociateFirewallRuleGroup", + "AssociateResolverEndpointIpAddress", + "AssociateResolverQueryLogConfig", + "AssociateResolverRule", + "CreateFirewallDomainList", + "CreateFirewallRule", + "CreateFirewallRuleGroup", + "CreateOutpostResolver", + "CreateResolverEndpoint", + "CreateResolverQueryLogConfig", + "CreateResolverRule", + "DeleteFirewallDomainList", + "DeleteFirewallRule", + "DeleteFirewallRuleGroup", + "DeleteOutpostResolver", + "DeleteResolverEndpoint", + "DeleteResolverQueryLogConfig", + "DeleteResolverRule", + "DisassociateFirewallRuleGroup", + "DisassociateResolverEndpointIpAddress", + "DisassociateResolverQueryLogConfig", + "DisassociateResolverRule", + "GetFirewallConfig", + "GetFirewallDomainList", + "GetFirewallRuleGroup", + "GetFirewallRuleGroupAssociation", + "GetFirewallRuleGroupPolicy", + "GetOutpostResolver", + "GetResolverConfig", + "GetResolverDnssecConfig", + "GetResolverEndpoint", + "GetResolverQueryLogConfig", + "GetResolverQueryLogConfigAssociation", + "GetResolverQueryLogConfigPolicy", + "GetResolverRule", + "GetResolverRuleAssociation", + "GetResolverRulePolicy", + "ImportFirewallDomains", + "ListFirewallConfigs", + "ListFirewallDomainLists", + "ListFirewallDomains", + "ListFirewallRuleGroupAssociations", + "ListFirewallRuleGroups", + "ListFirewallRules", + "ListOutpostResolvers", + "ListResolverConfigs", + "ListResolverDnssecConfigs", + "ListResolverEndpointIpAddresses", + "ListResolverEndpoints", + "ListResolverQueryLogConfigAssociations", + "ListResolverQueryLogConfigs", + "ListResolverRuleAssociations", + "ListResolverRules", + "ListTagsForResource", + "PutFirewallRuleGroupPolicy", + "PutResolverQueryLogConfigPolicy", + "PutResolverRulePolicy", + "TagResource", + "UntagResource", + "UpdateFirewallConfig", + "UpdateFirewallDomains", + "UpdateFirewallRule", + "UpdateFirewallRuleGroupAssociation", + "UpdateOutpostResolver", + "UpdateResolverConfig", + "UpdateResolverDnssecConfig", + "UpdateResolverEndpoint", + "UpdateResolverRule" + ] + }, + "s3": { + "protocol": "rest-xml", + "servedOps": [ + "AbortMultipartUpload", + "CompleteMultipartUpload", + "CopyObject", + "CreateBucket", + "CreateMultipartUpload", + "DeleteBucket", + "DeleteBucketCors", + "DeleteBucketPolicy", + "DeleteBucketTagging", + "DeleteObject", + "DeleteObjectTagging", + "DeleteObjects", + "GetBucketAcl", + "GetBucketCors", + "GetBucketLocation", + "GetBucketNotificationConfiguration", + "GetBucketPolicy", + "GetBucketTagging", + "GetBucketVersioning", + "GetObject", + "GetObjectTagging", + "HeadBucket", + "HeadObject", + "ListBuckets", + "ListMultipartUploads", + "ListObjects", + "ListObjectsV2", + "ListParts", + "PutBucketAcl", + "PutBucketCors", + "PutBucketNotificationConfiguration", + "PutBucketPolicy", + "PutBucketTagging", + "PutBucketVersioning", + "PutObject", + "PutObjectTagging", + "UploadPart" + ] + }, + "s3control": { + "protocol": "rest-xml", + "servedOps": [ + "CreateAccessGrant", + "CreateAccessGrantsInstance", + "CreateAccessGrantsLocation", + "CreateAccessPoint", + "CreateAccessPointForObjectLambda", + "CreateBucket", + "CreateJob", + "CreateMultiRegionAccessPoint", + "CreateStorageLensGroup", + "DeleteAccessGrant", + "DeleteAccessGrantsInstance", + "DeleteAccessGrantsInstanceResourcePolicy", + "DeleteAccessGrantsLocation", + "DeleteAccessPoint", + "DeleteAccessPointForObjectLambda", + "DeleteAccessPointPolicy", + "DeleteAccessPointPolicyForObjectLambda", + "DeleteAccessPointScope", + "DeleteBucket", + "DeleteBucketLifecycleConfiguration", + "DeleteBucketPolicy", + "DeleteBucketReplication", + "DeleteBucketTagging", + "DeleteJobTagging", + "DeleteMultiRegionAccessPoint", + "DeletePublicAccessBlock", + "DeleteStorageLensConfiguration", + "DeleteStorageLensConfigurationTagging", + "DeleteStorageLensGroup", + "DescribeJob", + "DescribeMultiRegionAccessPointOperation", + "GetAccessGrant", + "GetAccessGrantsInstance", + "GetAccessGrantsInstanceForPrefix", + "GetAccessGrantsInstanceResourcePolicy", + "GetAccessGrantsLocation", + "GetAccessPoint", + "GetAccessPointConfigurationForObjectLambda", + "GetAccessPointForObjectLambda", + "GetAccessPointPolicy", + "GetAccessPointPolicyForObjectLambda", + "GetAccessPointPolicyStatus", + "GetAccessPointPolicyStatusForObjectLambda", + "GetAccessPointScope", + "GetBucket", + "GetBucketLifecycleConfiguration", + "GetBucketPolicy", + "GetBucketReplication", + "GetBucketTagging", + "GetBucketVersioning", + "GetDataAccess", + "GetJobTagging", + "GetMultiRegionAccessPoint", + "GetMultiRegionAccessPointPolicy", + "GetMultiRegionAccessPointPolicyStatus", + "GetMultiRegionAccessPointRoutes", + "GetPublicAccessBlock", + "GetStorageLensConfiguration", + "GetStorageLensConfigurationTagging", + "GetStorageLensGroup", + "ListAccessGrants", + "ListAccessGrantsInstances", + "ListAccessGrantsLocations", + "ListAccessPoints", + "ListAccessPointsForDirectoryBuckets", + "ListAccessPointsForObjectLambda", + "ListCallerAccessGrants", + "ListJobs", + "ListMultiRegionAccessPoints", + "ListRegionalBuckets", + "ListStorageLensConfigurations", + "ListStorageLensGroups", + "ListTagsForResource", + "PutAccessGrantsInstanceResourcePolicy", + "PutAccessPointConfigurationForObjectLambda", + "PutAccessPointPolicy", + "PutAccessPointPolicyForObjectLambda", + "PutAccessPointScope", + "PutBucketLifecycleConfiguration", + "PutBucketPolicy", + "PutBucketReplication", + "PutBucketTagging", + "PutBucketVersioning", + "PutJobTagging", + "PutMultiRegionAccessPointPolicy", + "PutPublicAccessBlock", + "PutStorageLensConfiguration", + "PutStorageLensConfigurationTagging", + "TagResource", + "UntagResource", + "UpdateAccessGrantsLocation", + "UpdateJobPriority", + "UpdateJobStatus", + "UpdateStorageLensGroup" + ] + }, + "s3tables": { + "protocol": "", + "servedOps": [ + "CreateNamespace", + "CreateTable", + "CreateTableBucket", + "DeleteNamespace", + "DeleteTable", + "DeleteTableBucket", + "DeleteTableBucketEncryption", + "DeleteTableBucketPolicy", + "DeleteTableEncryption", + "DeleteTablePolicy", + "GetNamespace", + "GetTable", + "GetTableBucket", + "GetTableBucketEncryption", + "GetTableBucketMaintenanceConfiguration", + "GetTableBucketMaintenanceJobStatus", + "GetTableBucketPolicy", + "GetTableEncryption", + "GetTableMaintenanceConfiguration", + "GetTableMaintenanceJobStatus", + "GetTableMetadataLocation", + "GetTablePolicy", + "ListNamespaces", + "ListTableBuckets", + "ListTables", + "PutTableBucketEncryption", + "PutTableBucketMaintenanceConfiguration", + "PutTableBucketPolicy", + "PutTableEncryption", + "PutTableMaintenanceConfiguration", + "PutTablePolicy", + "RenameTable", + "UpdateTableMetadataLocation" + ] + }, + "s3vectors": { + "protocol": "rest-json", + "servedOps": [ + "CreateIndex", + "CreateVectorBucket", + "DeleteIndex", + "DeleteVectorBucket", + "DeleteVectorBucketPolicy", + "DeleteVectors", + "GetIndex", + "GetVectorBucket", + "GetVectorBucketPolicy", + "GetVectors", + "ListIndexes", + "ListTagsForResource", + "ListVectorBuckets", + "ListVectors", + "PutVectorBucketPolicy", + "PutVectors", + "TagResource", + "UntagResource" + ] + }, + "sagemaker": { + "protocol": "json-1.1", + "servedOps": [ + "AddTags", + "CreateAction", + "CreateAlgorithm", + "CreateApp", + "CreateAppImageConfig", + "CreateArtifact", + "CreateAutoMLJob", + "CreateAutoMLJobV2", + "CreateCluster", + "CreateClusterSchedulerConfig", + "CreateCodeRepository", + "CreateCompilationJob", + "CreateComputeQuota", + "CreateContext", + "CreateDataQualityJobDefinition", + "CreateDeviceFleet", + "CreateDomain", + "CreateEdgeDeploymentPlan", + "CreateEdgeDeploymentStage", + "CreateEdgePackagingJob", + "CreateEndpoint", + "CreateEndpointConfig", + "CreateExperiment", + "CreateFeatureGroup", + "CreateFlowDefinition", + "CreateHub", + "CreateHubContentPresignedUrls", + "CreateHubContentReference", + "CreateHumanTaskUi", + "CreateHyperParameterTuningJob", + "CreateImage", + "CreateImageVersion", + "CreateInferenceComponent", + "CreateInferenceExperiment", + "CreateInferenceRecommendationsJob", + "CreateLabelingJob", + "CreateMlflowApp", + "CreateMlflowTrackingServer", + "CreateModel", + "CreateModelBiasJobDefinition", + "CreateModelCard", + "CreateModelCardExportJob", + "CreateModelExplainabilityJobDefinition", + "CreateModelPackage", + "CreateModelPackageGroup", + "CreateModelQualityJobDefinition", + "CreateMonitoringSchedule", + "CreateNotebookInstance", + "CreateNotebookInstanceLifecycleConfig", + "CreateOptimizationJob", + "CreatePartnerApp", + "CreatePartnerAppPresignedUrl", + "CreatePipeline", + "CreatePresignedDomainUrl", + "CreatePresignedMlflowAppUrl", + "CreatePresignedMlflowTrackingServerUrl", + "CreatePresignedNotebookInstanceUrl", + "CreateProcessingJob", + "CreateProject", + "CreateSpace", + "CreateStudioLifecycleConfig", + "CreateTrainingJob", + "CreateTrainingPlan", + "CreateTransformJob", + "CreateTrial", + "CreateTrialComponent", + "CreateUserProfile", + "CreateWorkforce", + "CreateWorkteam", + "DeleteAction", + "DeleteAlgorithm", + "DeleteApp", + "DeleteAppImageConfig", + "DeleteArtifact", + "DeleteAssociation", + "DeleteCluster", + "DeleteClusterSchedulerConfig", + "DeleteCodeRepository", + "DeleteCompilationJob", + "DeleteComputeQuota", + "DeleteContext", + "DeleteDataQualityJobDefinition", + "DeleteDeviceFleet", + "DeleteDomain", + "DeleteEdgeDeploymentPlan", + "DeleteEdgeDeploymentStage", + "DeleteEndpoint", + "DeleteEndpointConfig", + "DeleteExperiment", + "DeleteFeatureGroup", + "DeleteFlowDefinition", + "DeleteHub", + "DeleteHubContent", + "DeleteHubContentReference", + "DeleteHumanTaskUi", + "DeleteHyperParameterTuningJob", + "DeleteImage", + "DeleteImageVersion", + "DeleteInferenceComponent", + "DeleteInferenceExperiment", + "DeleteMlflowApp", + "DeleteMlflowTrackingServer", + "DeleteModel", + "DeleteModelBiasJobDefinition", + "DeleteModelCard", + "DeleteModelExplainabilityJobDefinition", + "DeleteModelPackage", + "DeleteModelPackageGroup", + "DeleteModelPackageGroupPolicy", + "DeleteModelQualityJobDefinition", + "DeleteMonitoringSchedule", + "DeleteNotebookInstance", + "DeleteNotebookInstanceLifecycleConfig", + "DeleteOptimizationJob", + "DeletePartnerApp", + "DeletePipeline", + "DeleteProcessingJob", + "DeleteProject", + "DeleteSpace", + "DeleteStudioLifecycleConfig", + "DeleteTags", + "DeleteTrainingJob", + "DeleteTrial", + "DeleteTrialComponent", + "DeleteUserProfile", + "DeleteWorkforce", + "DeleteWorkteam", + "DeregisterDevices", + "DescribeAction", + "DescribeAlgorithm", + "DescribeApp", + "DescribeAppImageConfig", + "DescribeArtifact", + "DescribeAutoMLJob", + "DescribeAutoMLJobV2", + "DescribeCluster", + "DescribeClusterEvent", + "DescribeClusterNode", + "DescribeClusterSchedulerConfig", + "DescribeCodeRepository", + "DescribeCompilationJob", + "DescribeComputeQuota", + "DescribeContext", + "DescribeDataQualityJobDefinition", + "DescribeDevice", + "DescribeDeviceFleet", + "DescribeDomain", + "DescribeEdgeDeploymentPlan", + "DescribeEdgePackagingJob", + "DescribeEndpoint", + "DescribeEndpointConfig", + "DescribeExperiment", + "DescribeFeatureGroup", + "DescribeFeatureMetadata", + "DescribeFlowDefinition", + "DescribeHub", + "DescribeHubContent", + "DescribeHumanTaskUi", + "DescribeHyperParameterTuningJob", + "DescribeImage", + "DescribeImageVersion", + "DescribeInferenceComponent", + "DescribeInferenceExperiment", + "DescribeInferenceRecommendationsJob", + "DescribeLabelingJob", + "DescribeLineageGroup", + "DescribeMlflowApp", + "DescribeMlflowTrackingServer", + "DescribeModel", + "DescribeModelBiasJobDefinition", + "DescribeModelCard", + "DescribeModelCardExportJob", + "DescribeModelExplainabilityJobDefinition", + "DescribeModelPackage", + "DescribeModelPackageGroup", + "DescribeModelQualityJobDefinition", + "DescribeMonitoringSchedule", + "DescribeNotebookInstance", + "DescribeNotebookInstanceLifecycleConfig", + "DescribeOptimizationJob", + "DescribePartnerApp", + "DescribePipeline", + "DescribePipelineDefinitionForExecution", + "DescribePipelineExecution", + "DescribeProcessingJob", + "DescribeProject", + "DescribeReservedCapacity", + "DescribeSpace", + "DescribeStudioLifecycleConfig", + "DescribeSubscribedWorkteam", + "DescribeTrainingJob", + "DescribeTrainingPlan", + "DescribeTrainingPlanExtensionHistory", + "DescribeTransformJob", + "DescribeTrial", + "DescribeTrialComponent", + "DescribeUserProfile", + "DescribeWorkforce", + "DescribeWorkteam", + "GetDeviceFleetReport", + "GetLineageGroupPolicy", + "GetModelPackageGroupPolicy", + "GetSagemakerServicecatalogPortfolioStatus", + "GetScalingConfigurationRecommendation", + "GetSearchSuggestions", + "ListActions", + "ListAlgorithms", + "ListAliases", + "ListAppImageConfigs", + "ListApps", + "ListArtifacts", + "ListAssociations", + "ListAutoMLJobs", + "ListCandidatesForAutoMLJob", + "ListClusterEvents", + "ListClusterNodes", + "ListClusterSchedulerConfigs", + "ListClusters", + "ListCodeRepositories", + "ListCompilationJobs", + "ListComputeQuotas", + "ListContexts", + "ListDataQualityJobDefinitions", + "ListDeviceFleets", + "ListDevices", + "ListDomains", + "ListEdgeDeploymentPlans", + "ListEdgePackagingJobs", + "ListEndpointConfigs", + "ListEndpoints", + "ListExperiments", + "ListFeatureGroups", + "ListFlowDefinitions", + "ListHubContentVersions", + "ListHubContents", + "ListHubs", + "ListHumanTaskUis", + "ListHyperParameterTuningJobs", + "ListImageVersions", + "ListImages", + "ListInferenceComponents", + "ListInferenceExperiments", + "ListInferenceRecommendationsJobSteps", + "ListInferenceRecommendationsJobs", + "ListLabelingJobs", + "ListLabelingJobsForWorkteam", + "ListLineageGroups", + "ListMlflowApps", + "ListMlflowTrackingServers", + "ListModelBiasJobDefinitions", + "ListModelCardExportJobs", + "ListModelCardVersions", + "ListModelCards", + "ListModelExplainabilityJobDefinitions", + "ListModelMetadata", + "ListModelPackageGroups", + "ListModelPackages", + "ListModelQualityJobDefinitions", + "ListModels", + "ListMonitoringAlertHistory", + "ListMonitoringAlerts", + "ListMonitoringExecutions", + "ListMonitoringSchedules", + "ListNotebookInstanceLifecycleConfigs", + "ListNotebookInstances", + "ListOptimizationJobs", + "ListPartnerApps", + "ListPipelineExecutionSteps", + "ListPipelineExecutions", + "ListPipelineParametersForExecution", + "ListPipelineVersions", + "ListPipelines", + "ListProcessingJobs", + "ListProjects", + "ListResourceCatalogs", + "ListSpaces", + "ListStageDevices", + "ListStudioLifecycleConfigs", + "ListSubscribedWorkteams", + "ListTags", + "ListTrainingJobs", + "ListTrainingJobsForHyperParameterTuningJob", + "ListTrainingPlans", + "ListTransformJobs", + "ListTrialComponents", + "ListTrials", + "ListUltraServersByReservedCapacity", + "ListUserProfiles", + "ListWorkforces", + "ListWorkteams", + "PutModelPackageGroupPolicy", + "RegisterDevices", + "Search", + "StartNotebookInstance", + "StartPipelineExecution", + "StopNotebookInstance", + "StopPipelineExecution", + "StopProcessingJob", + "StopTrainingJob", + "StopTransformJob", + "UpdateAction", + "UpdateAppImageConfig", + "UpdateArtifact", + "UpdateCluster", + "UpdateClusterSchedulerConfig", + "UpdateClusterSoftware", + "UpdateCodeRepository", + "UpdateComputeQuota", + "UpdateContext", + "UpdateDeviceFleet", + "UpdateDevices", + "UpdateDomain", + "UpdateEndpoint", + "UpdateEndpointWeightsAndCapacities", + "UpdateExperiment", + "UpdateFeatureGroup", + "UpdateFeatureMetadata", + "UpdateHub", + "UpdateHubContent", + "UpdateHubContentReference", + "UpdateImage", + "UpdateImageVersion", + "UpdateInferenceComponent", + "UpdateInferenceComponentRuntimeConfig", + "UpdateInferenceExperiment", + "UpdateMlflowApp", + "UpdateMlflowTrackingServer", + "UpdateModelCard", + "UpdateModelPackage", + "UpdateMonitoringAlert", + "UpdateMonitoringSchedule", + "UpdateNotebookInstance", + "UpdateNotebookInstanceLifecycleConfig", + "UpdatePartnerApp", + "UpdatePipeline", + "UpdatePipelineExecution", + "UpdatePipelineVersion", + "UpdateProject", + "UpdateSpace", + "UpdateTrainingJob", + "UpdateTrial", + "UpdateTrialComponent", + "UpdateUserProfile", + "UpdateWorkforce", + "UpdateWorkteam" + ] + }, + "sagemakera2iruntime": { + "protocol": "rest-json", + "servedOps": [ + "DeleteHumanLoop", + "DescribeHumanLoop", + "ListHumanLoops" + ] + }, + "sagemakeredge": { + "protocol": "rest-json", + "servedOps": [ + "GetDeployments", + "GetDeviceRegistration" + ] + }, + "sagemakerfeaturestoreruntime": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetRecord", + "DeleteRecord", + "GetRecord", + "ListRecords", + "PutRecord", + "UpdateRecord" + ] + }, + "sagemakergeospatial": { + "protocol": "rest-json", + "servedOps": [ + "DeleteEarthObservationJob", + "DeleteVectorEnrichmentJob", + "GetEarthObservationJob", + "GetRasterDataCollection", + "GetTile", + "GetVectorEnrichmentJob", + "ListEarthObservationJobs", + "ListRasterDataCollections", + "ListTagsForResource", + "ListVectorEnrichmentJobs", + "TagResource", + "UntagResource" + ] + }, + "sagemakerjobruntime": { + "protocol": "rest-json", + "servedOps": [ + "UpdateReward" + ] + }, + "sagemakermetrics": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetMetrics" + ] + }, + "sagemakerruntime": { + "protocol": "rest-json", + "servedOps": [] + }, + "sagemakerruntimehttp2": { + "protocol": "rest-json", + "servedOps": [] + }, + "scheduler": { + "protocol": "", + "servedOps": [ + "BatchCheckMaxRateLimits", + "BatchCreateSchedules", + "BatchDeleteSchedules", + "BatchUpdateSchedules", + "CreateSchedule", + "CreateScheduleGroup", + "DeleteRateLimit", + "DeleteSchedule", + "DeleteScheduleGroup", + "DisableSchedule", + "EnableSchedule", + "GetRateLimit", + "GetSchedule", + "GetScheduleAuditLogs", + "GetScheduleExecutionStatus", + "GetScheduleGroup", + "GetScheduleGroupMetrics", + "GetScheduleMetrics", + "ListConnections", + "ListFleetSchedules", + "ListRateLimits", + "ListScheduleAuditLogs", + "ListScheduleExecutions", + "ListScheduleGroups", + "ListScheduleMetrics", + "ListSchedules", + "ListTagsForResource", + "LockSchedule", + "PreviewSchedule", + "PutRateLimit", + "StopScheduleExecution", + "TagResource", + "UnlockSchedule", + "UntagResource", + "UpdateSchedule", + "UpdateScheduleGroup", + "ValidateScheduleExpression" + ] + }, + "secretsmanager": { + "protocol": "json-1.1", + "servedOps": [ + "BatchGetSecretValue", + "CancelRotateSecret", + "ClearSecretValue", + "CreateSecret", + "DeleteResourcePolicy", + "DeleteSecret", + "DescribeSecret", + "DescribeSecretVersion", + "DisableSecretRotation", + "EnableSecretRotation", + "GetRandomPassword", + "GetResourcePolicy", + "GetRotationStatus", + "GetSecret", + "GetSecretCounter", + "GetSecretHistory", + "GetSecretMetadata", + "GetSecretValue", + "GetSecretVersion", + "ListReplicationRegions", + "ListRotationLambdas", + "ListSecretTags", + "ListSecretVersionIds", + "ListSecrets", + "ListTagsForResource", + "PutResourcePolicy", + "PutSecretMetadata", + "PutSecretValue", + "PutSecretValueBinary", + "RemoveRegionsFromReplication", + "ReplicateSecretToRegions", + "RestoreSecret", + "RotateSecret", + "StopReplicationToReplica", + "TagResource", + "UntagResource", + "UpdateSecret", + "UpdateSecretVersionStage", + "ValidateResourcePolicy", + "ValidateSecret" + ] + }, + "securityhub": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetAutomationRules", + "BatchGetConfigurationPolicyAssociations", + "BatchGetSecurityControls", + "BatchGetStandardsControlAssociations", + "CreateActionTarget", + "CreateAggregatorV2", + "CreateAutomationRule", + "CreateAutomationRuleV2", + "CreateConfigurationPolicy", + "CreateConnector", + "CreateConnectorV2", + "CreateFindingAggregator", + "CreateInsight", + "CreateMembers", + "CreateTicketV2", + "DeleteActionTarget", + "DeleteAggregatorV2", + "DeleteAutomationRuleV2", + "DeleteConfigurationPolicy", + "DeleteConnector", + "DeleteConnectorV2", + "DeleteFindingAggregator", + "DeleteInsight", + "DeleteInvitations", + "DeleteMembers", + "DescribeActionTargets", + "DescribeHub", + "DescribeOrganizationConfiguration", + "DescribeProducts", + "DescribeProductsV2", + "DescribeSecurityHubV2", + "DescribeStandards", + "DescribeStandardsControls", + "GetAdministratorAccount", + "GetAggregatorV2", + "GetAutomationRuleV2", + "GetConfigurationPolicy", + "GetConfigurationPolicyAssociation", + "GetConnector", + "GetConnectorV2", + "GetEnabledStandards", + "GetFindingAggregator", + "GetFindingHistory", + "GetFindingStatisticsV2", + "GetFindings", + "GetFindingsTrendsV2", + "GetFindingsV2", + "GetInsightResults", + "GetInsights", + "GetInvitationsCount", + "GetMasterAccount", + "GetMembers", + "GetRecommendedPolicyV2", + "GetResourcesStatisticsV2", + "GetResourcesTrendsV2", + "GetResourcesV2", + "GetSecurityControlDefinition", + "ListAggregatorsV2", + "ListAutomationRules", + "ListAutomationRulesV2", + "ListConfigurationPolicies", + "ListConfigurationPolicyAssociations", + "ListConnectors", + "ListConnectorsV2", + "ListEnabledProductsForImport", + "ListFindingAggregators", + "ListFreeTrialStatusesV2", + "ListInvitations", + "ListMembers", + "ListOrganizationAdminAccounts", + "ListSecurityControlDefinitions", + "ListStandardsControlAssociations", + "ListTagsForResource", + "RegisterConnectorV2", + "TagResource", + "UntagResource", + "UpdateActionTarget", + "UpdateAggregatorV2", + "UpdateAutomationRuleV2", + "UpdateConfigurationPolicy", + "UpdateConnector", + "UpdateConnectorV2", + "UpdateFindingAggregator", + "UpdateFindings", + "UpdateInsight", + "UpdateOrganizationConfiguration", + "UpdateSecurityControl", + "UpdateSecurityHubConfiguration", + "UpdateStandardsControl" + ] + }, + "serverlessrepo": { + "protocol": "", + "servedOps": [ + "AddApplicationDependency", + "CancelCloudFormationChangeSet", + "CreateApplication", + "CreateApplicationVersion", + "CreateCloudFormationChangeSet", + "CreateCloudFormationTemplate", + "DeleteApplication", + "DeleteApplicationPolicy", + "DeleteApplicationVersion", + "DeleteCloudFormationChangeSet", + "ExecuteCloudFormationChangeSet", + "GetApplication", + "GetApplicationPolicy", + "GetApplicationPublishStatus", + "GetApplicationShares", + "GetApplicationStatistics", + "GetApplicationVersion", + "GetCloudFormationChangeSet", + "GetCloudFormationTemplate", + "ListApplicationDependencies", + "ListApplicationDeployments", + "ListApplicationReviews", + "ListApplicationShares", + "ListApplicationVersions", + "ListApplications", + "ListCategories", + "ListCloudFormationChangeSets", + "ListCloudFormationTemplates", + "ListTagsForResource", + "PublishApplication", + "PutApplicationPolicy", + "RemoveApplicationDependency", + "SearchApplications", + "ShareApplication", + "SubmitApplicationReview", + "TagResource", + "UnpublishApplication", + "UnshareApplication", + "UntagResource", + "UpdateApplication", + "UpdateApplicationVersion" + ] + }, + "servicecatalog": { + "protocol": "json-1.1", + "servedOps": [ + "CreateConstraint", + "CreatePortfolio", + "CreatePortfolioShare", + "CreateProduct", + "CreateProvisionedProductPlan", + "CreateProvisioningArtifact", + "CreateServiceAction", + "CreateTagOption", + "DeleteConstraint", + "DeletePortfolio", + "DeletePortfolioShare", + "DeleteProduct", + "DeleteProvisionedProductPlan", + "DeleteProvisioningArtifact", + "DeleteServiceAction", + "DeleteTagOption", + "DescribeConstraint", + "DescribeCopyProductStatus", + "DescribePortfolio", + "DescribePortfolioShareStatus", + "DescribePortfolioShares", + "DescribeProduct", + "DescribeProductAsAdmin", + "DescribeProductView", + "DescribeProvisionedProduct", + "DescribeProvisionedProductPlan", + "DescribeProvisioningArtifact", + "DescribeProvisioningParameters", + "DescribeRecord", + "DescribeServiceAction", + "DescribeServiceActionExecutionParameters", + "DescribeTagOption", + "GetAWSOrganizationsAccessStatus", + "GetProvisionedProductOutputs", + "ListAcceptedPortfolioShares", + "ListBudgetsForResource", + "ListConstraintsForPortfolio", + "ListLaunchPaths", + "ListOrganizationPortfolioAccess", + "ListPortfolioAccess", + "ListPortfolios", + "ListPortfoliosForProduct", + "ListPrincipalsForPortfolio", + "ListProvisionedProductPlans", + "ListProvisioningArtifacts", + "ListProvisioningArtifactsForServiceAction", + "ListRecordHistory", + "ListResourcesForTagOption", + "ListServiceActions", + "ListServiceActionsForProvisioningArtifact", + "ListStackInstancesForProvisionedProduct", + "ListTagOptions", + "UpdateConstraint", + "UpdatePortfolio", + "UpdatePortfolioShare", + "UpdateProduct", + "UpdateProvisionedProduct", + "UpdateProvisionedProductProperties", + "UpdateProvisioningArtifact", + "UpdateServiceAction", + "UpdateTagOption" + ] + }, + "servicecatalogappregistry": { + "protocol": "rest-json", + "servedOps": [ + "CreateApplication", + "CreateAttributeGroup", + "DeleteApplication", + "DeleteAttributeGroup", + "GetApplication", + "GetAssociatedResource", + "GetAttributeGroup", + "GetConfiguration", + "ListApplications", + "ListAssociatedAttributeGroups", + "ListAssociatedResources", + "ListAttributeGroups", + "ListAttributeGroupsForApplication", + "ListTagsForResource", + "PutConfiguration", + "TagResource", + "UntagResource", + "UpdateApplication", + "UpdateAttributeGroup" + ] + }, + "servicediscovery": { + "protocol": "json-1.1", + "servedOps": [ + "CreateHttpNamespace", + "CreatePrivateDnsNamespace", + "CreatePublicDnsNamespace", + "CreateService", + "DeleteNamespace", + "DeleteService", + "DeleteServiceAttributes", + "DeregisterInstance", + "DiscoverInstances", + "DiscoverInstancesRevision", + "GetInstance", + "GetInstancesHealthStatus", + "GetNamespace", + "GetOperation", + "GetService", + "GetServiceAttributes", + "ListInstances", + "ListNamespaces", + "ListOperations", + "ListServices", + "ListTagsForResource", + "RegisterInstance", + "TagResource", + "UntagResource", + "UpdateHttpNamespace", + "UpdateInstanceCustomHealthStatus", + "UpdatePrivateDnsNamespace", + "UpdatePublicDnsNamespace", + "UpdateService", + "UpdateServiceAttributes" + ] + }, + "servicequotas": { + "protocol": "json-1.1", + "servedOps": [ + "CreateSupportCase", + "DeleteServiceQuotaIncreaseRequestFromTemplate", + "GetAWSDefaultServiceQuota", + "GetAssociationForServiceQuotaTemplate", + "GetAutoManagementConfiguration", + "GetQuotaUtilizationReport", + "GetRequestedServiceQuotaChange", + "GetServiceQuota", + "GetServiceQuotaIncreaseRequestFromTemplate", + "ListAWSDefaultServiceQuotas", + "ListRequestedServiceQuotaChangeHistory", + "ListRequestedServiceQuotaChangeHistoryByQuota", + "ListServiceQuotaIncreaseRequestsInTemplate", + "ListServiceQuotas", + "ListServices", + "ListTagsForResource", + "PutServiceQuotaIncreaseRequestIntoTemplate", + "TagResource", + "UntagResource", + "UpdateAutoManagement" + ] + }, + "ses": { + "protocol": "query", + "servedOps": [ + "CloneReceiptRuleSet", + "CreateConfigurationSet", + "CreateConfigurationSetEventDestination", + "CreateConfigurationSetTrackingOptions", + "CreateCustomVerificationEmailTemplate", + "CreateReceiptFilter", + "CreateReceiptRule", + "CreateReceiptRuleSet", + "CreateTemplate", + "DeleteConfigurationSet", + "DeleteConfigurationSetEventDestination", + "DeleteConfigurationSetTrackingOptions", + "DeleteCustomVerificationEmailTemplate", + "DeleteIdentity", + "DeleteIdentityPolicy", + "DeleteReceiptFilter", + "DeleteReceiptRule", + "DeleteReceiptRuleSet", + "DeleteTemplate", + "DeleteVerifiedEmailAddress", + "DescribeActiveReceiptRuleSet", + "DescribeConfigurationSet", + "DescribeConfigurationSetEventDestinations", + "DescribeReceiptRule", + "DescribeReceiptRuleSet", + "GetAccountSendingEnabled", + "GetCustomVerificationEmailTemplate", + "GetIdentityDkimAttributes", + "GetIdentityMailFromDomainAttributes", + "GetIdentityNotificationAttributes", + "GetIdentityPolicies", + "GetIdentityVerificationAttributes", + "GetSendQuota", + "GetSendStatistics", + "GetTemplate", + "ListConfigurationSetEventDestinations", + "ListConfigurationSets", + "ListCustomVerificationEmailTemplates", + "ListIdentities", + "ListIdentityPolicies", + "ListReceiptFilters", + "ListReceiptRuleSets", + "ListTagsForResource", + "ListTemplates", + "ListVerifiedEmailAddresses", + "PutIdentityPolicy", + "ReorderReceiptRuleSet", + "SendBounce", + "SendBulkTemplatedEmail", + "SendCustomVerificationEmail", + "SendEmail", + "SendRawEmail", + "SendTemplatedEmail", + "SetActiveReceiptRuleSet", + "SetIdentityDkimEnabled", + "SetIdentityFeedbackForwardingEnabled", + "SetIdentityHeadersInNotificationsEnabled", + "SetIdentityMailFromDomain", + "SetIdentityNotificationTopic", + "SetReceiptRulePosition", + "TagResource", + "TestRenderTemplate", + "UntagResource", + "UpdateAccountSendingEnabled", + "UpdateConfigurationSetEventDestination", + "UpdateConfigurationSetTrackingOptions", + "UpdateCustomVerificationEmailTemplate", + "UpdateReceiptRule", + "UpdateTemplate", + "VerifyDomainDkim", + "VerifyDomainIdentity", + "VerifyEmailAddress", + "VerifyEmailIdentity" + ] + }, + "sesv2": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetMetricData", + "CancelExportJob", + "CreateConfigurationSet", + "CreateConfigurationSetEventDestination", + "CreateContact", + "CreateContactList", + "CreateCustomVerificationEmailTemplate", + "CreateDedicatedIpPool", + "CreateDeliverabilityTestReport", + "CreateEmailIdentity", + "CreateEmailIdentityPolicy", + "CreateEmailTemplate", + "CreateExportJob", + "CreateImportJob", + "CreateMultiRegionEndpoint", + "CreateTenant", + "CreateTenantResourceAssociation", + "DeleteConfigurationSet", + "DeleteConfigurationSetEventDestination", + "DeleteContact", + "DeleteContactList", + "DeleteCustomVerificationEmailTemplate", + "DeleteDedicatedIpPool", + "DeleteEmailIdentity", + "DeleteEmailIdentityPolicy", + "DeleteEmailTemplate", + "DeleteMultiRegionEndpoint", + "DeleteSuppressedDestination", + "DeleteTenant", + "DeleteTenantResourceAssociation", + "GetAccount", + "GetBlacklistReports", + "GetConfigurationSet", + "GetConfigurationSetEventDestinations", + "GetContact", + "GetContactList", + "GetCustomVerificationEmailTemplate", + "GetDedicatedIp", + "GetDedicatedIpPool", + "GetDedicatedIps", + "GetDeliverabilityDashboardOptions", + "GetDeliverabilityTestReport", + "GetDomainDeliverabilityCampaign", + "GetDomainStatisticsReport", + "GetEmailAddressInsights", + "GetEmailIdentity", + "GetEmailIdentityPolicies", + "GetEmailTemplate", + "GetExportJob", + "GetImportJob", + "GetMessageInsights", + "GetMultiRegionEndpoint", + "GetReputationEntity", + "GetSuppressedDestination", + "GetTenant", + "ListConfigurationSets", + "ListContactLists", + "ListContacts", + "ListCustomVerificationEmailTemplates", + "ListDedicatedIpPools", + "ListDeliverabilityTestReports", + "ListDomainDeliverabilityCampaigns", + "ListEmailIdentities", + "ListEmailTemplates", + "ListExportJobs", + "ListImportJobs", + "ListMultiRegionEndpoints", + "ListRecommendations", + "ListReputationEntities", + "ListResourceTenants", + "ListSuppressedDestinations", + "ListTagsForResource", + "ListTenantResources", + "ListTenants", + "PutAccountDedicatedIpWarmupAttributes", + "PutAccountDetails", + "PutAccountSendingAttributes", + "PutAccountSuppressionAttributes", + "PutAccountVdmAttributes", + "PutConfigurationSetArchivingOptions", + "PutConfigurationSetDeliveryOptions", + "PutConfigurationSetReputationOptions", + "PutConfigurationSetSendingOptions", + "PutConfigurationSetSuppressionOptions", + "PutConfigurationSetTrackingOptions", + "PutConfigurationSetVdmOptions", + "PutDedicatedIpInPool", + "PutDedicatedIpPoolScalingAttributes", + "PutDedicatedIpWarmupAttributes", + "PutDeliverabilityDashboardOption", + "PutEmailIdentityConfigurationSetAttributes", + "PutEmailIdentityDkimAttributes", + "PutEmailIdentityDkimSigningAttributes", + "PutEmailIdentityFeedbackAttributes", + "PutEmailIdentityMailFromAttributes", + "PutSuppressedDestination", + "SendBulkEmail", + "SendCustomVerificationEmail", + "SendEmail", + "TagResource", + "TestRenderEmailTemplate", + "UntagResource", + "UpdateConfigurationSetEventDestination", + "UpdateContact", + "UpdateContactList", + "UpdateCustomVerificationEmailTemplate", + "UpdateEmailIdentityPolicy", + "UpdateEmailTemplate", + "UpdateReputationEntityCustomerManagedStatus", + "UpdateReputationEntityPolicy" + ] + }, + "sfn": { + "protocol": "json-1.0", + "servedOps": [ + "CreateActivity", + "CreateStateMachine", + "CreateStateMachineAlias", + "DeleteActivity", + "DeleteStateMachine", + "DeleteStateMachineAlias", + "DeleteStateMachineVersion", + "DescribeActivity", + "DescribeExecution", + "DescribeMapRun", + "DescribeStateMachine", + "DescribeStateMachineAlias", + "DescribeStateMachineForExecution", + "GetActivityTask", + "GetExecutionHistory", + "ListActivities", + "ListExecutions", + "ListMapRuns", + "ListStateMachineAliases", + "ListStateMachineVersions", + "ListStateMachines", + "ListTagsForResource", + "PublishStateMachineVersion", + "RedriveExecution", + "SendTaskFailure", + "SendTaskHeartbeat", + "SendTaskSuccess", + "StartExecution", + "StartSyncExecution", + "StopExecution", + "TagResource", + "TestState", + "UntagResource", + "UpdateMapRun", + "UpdateStateMachine", + "UpdateStateMachineAlias", + "ValidateStateMachineDefinition" + ] + }, + "shield": { + "protocol": "json-1.1", + "servedOps": [ + "AssociateDRTLogBucket", + "AssociateDRTRole", + "AssociateHealthCheck", + "AssociateProactiveEngagementDetails", + "CreateProtection", + "CreateProtectionGroup", + "CreateSubscription", + "DeleteProtection", + "DeleteProtectionGroup", + "DeleteSubscription", + "DescribeAttack", + "DescribeAttackStatistics", + "DescribeDRTAccess", + "DescribeEmergencyContactSettings", + "DescribeProtection", + "DescribeProtectionGroup", + "DescribeSubscription", + "DisableApplicationLayerAutomaticResponse", + "DisableProactiveEngagement", + "DisassociateDRTLogBucket", + "DisassociateDRTRole", + "DisassociateHealthCheck", + "EnableApplicationLayerAutomaticResponse", + "EnableProactiveEngagement", + "GetSubscriptionState", + "ListAttacks", + "ListProtectionGroups", + "ListProtections", + "ListResourcesInProtectionGroup", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateApplicationLayerAutomaticResponse", + "UpdateEmergencyContactSettings", + "UpdateProtectionGroup", + "UpdateSubscription" + ] + }, + "signer": { + "protocol": "rest-json", + "servedOps": [ + "DescribeSigningJob", + "GetRevocationStatus", + "GetSigningPlatform", + "GetSigningProfile", + "ListProfilePermissions", + "ListSigningJobs", + "ListSigningPlatforms", + "ListSigningProfiles", + "ListTagsForResource", + "PutSigningProfile", + "TagResource", + "UntagResource" + ] + }, + "sns": { + "protocol": "query", + "servedOps": [ + "AddPermission", + "CheckIfPhoneNumberIsOptedOut", + "ConfirmSubscription", + "CreateTopic", + "DeleteTopic", + "GetDataProtectionPolicy", + "GetSubscriptionAttributes", + "GetTopicAttributes", + "ListPhoneNumbersOptedOut", + "ListSubscriptions", + "ListSubscriptionsByTopic", + "ListTagsForResource", + "ListTopics", + "Publish", + "PutDataProtectionPolicy", + "RemovePermission", + "SetSubscriptionAttributes", + "SetTopicAttributes", + "Subscribe", + "TagResource", + "Unsubscribe", + "UntagResource" + ] + }, + "sqs": { + "protocol": "json-1.0", + "servedOps": [ + "AddPermission", + "CancelMessageMoveTask", + "ChangeMessageVisibility", + "ChangeMessageVisibilityBatch", + "CreateQueue", + "DeleteMessage", + "DeleteMessageBatch", + "DeleteQueue", + "GetQueueAttributes", + "GetQueueUrl", + "ListDeadLetterSourceQueues", + "ListMessageMoveTasks", + "ListQueueTags", + "ListQueues", + "PurgeQueue", + "ReceiveMessage", + "RemovePermission", + "SendMessage", + "SendMessageBatch", + "SetQueueAttributes", + "StartMessageMoveTask", + "TagQueue", + "UntagQueue" + ] + }, + "ssm": { + "protocol": "json-1.1", + "servedOps": [ + "AddTagsToResource", + "CreateActivation", + "CreateAssociation", + "CreateAssociationBatch", + "CreateDocument", + "CreateMaintenanceWindow", + "CreateOpsItem", + "CreateOpsMetadata", + "CreatePatchBaseline", + "CreateResourceDataSync", + "DeleteActivation", + "DeleteAssociation", + "DeleteDocument", + "DeleteInventory", + "DeleteMaintenanceWindow", + "DeleteOpsItem", + "DeleteOpsMetadata", + "DeleteParameter", + "DeleteParameters", + "DeletePatchBaseline", + "DeleteResourceDataSync", + "DeleteResourcePolicy", + "DeregisterManagedInstance", + "DeregisterPatchBaselineForPatchGroup", + "DeregisterTargetFromMaintenanceWindow", + "DeregisterTaskFromMaintenanceWindow", + "DescribeActivations", + "DescribeAssociation", + "DescribeAssociationExecutionTargets", + "DescribeAssociationExecutions", + "DescribeAutomationExecutions", + "DescribeAutomationStepExecutions", + "DescribeAvailablePatches", + "DescribeDocument", + "DescribeDocumentPermission", + "DescribeEffectiveInstanceAssociations", + "DescribeEffectivePatchesForPatchBaseline", + "DescribeInstanceAssociationsStatus", + "DescribeInstanceInformation", + "DescribeInstancePatchStates", + "DescribeInstancePatchStatesForPatchGroup", + "DescribeInstancePatches", + "DescribeInstanceProperties", + "DescribeInventoryDeletions", + "DescribeMaintenanceWindowExecutionTaskInvocations", + "DescribeMaintenanceWindowExecutionTasks", + "DescribeMaintenanceWindowExecutions", + "DescribeMaintenanceWindowSchedule", + "DescribeMaintenanceWindowTargets", + "DescribeMaintenanceWindowTasks", + "DescribeMaintenanceWindows", + "DescribeMaintenanceWindowsForTarget", + "DescribeOpsItems", + "DescribeParameters", + "DescribePatchBaselines", + "DescribePatchGroupState", + "DescribePatchGroups", + "DescribePatchProperties", + "DescribeSessions", + "GetAccessToken", + "GetAutomationExecution", + "GetCalendarState", + "GetCommandInvocation", + "GetConnectionStatus", + "GetDefaultPatchBaseline", + "GetDeployablePatchSnapshotForInstance", + "GetDocument", + "GetExecutionPreview", + "GetInventory", + "GetInventorySchema", + "GetMaintenanceWindow", + "GetMaintenanceWindowExecution", + "GetMaintenanceWindowExecutionTask", + "GetMaintenanceWindowExecutionTaskInvocation", + "GetMaintenanceWindowTask", + "GetOpsItem", + "GetOpsMetadata", + "GetOpsSummary", + "GetParameter", + "GetParameterHistory", + "GetParameters", + "GetParametersByPath", + "GetPatchBaseline", + "GetPatchBaselineForPatchGroup", + "GetResourcePolicies", + "GetServiceSetting", + "LabelParameterVersion", + "ListAssociationVersions", + "ListAssociations", + "ListCommandInvocations", + "ListCommands", + "ListComplianceItems", + "ListComplianceSummaries", + "ListDocumentMetadataHistory", + "ListDocumentVersions", + "ListDocuments", + "ListInventoryEntries", + "ListNodes", + "ListNodesSummary", + "ListOpsItemEvents", + "ListOpsItemRelatedItems", + "ListOpsMetadata", + "ListResourceComplianceSummaries", + "ListResourceDataSync", + "ListTagsForResource", + "ModifyDocumentPermission", + "PutComplianceItems", + "PutInventory", + "PutParameter", + "PutResourcePolicy", + "RegisterDefaultPatchBaseline", + "RegisterPatchBaselineForPatchGroup", + "RegisterTargetWithMaintenanceWindow", + "RegisterTaskWithMaintenanceWindow", + "RemoveTagsFromResource", + "StartSession", + "TerminateSession", + "UpdateAssociation", + "UpdateAssociationStatus", + "UpdateDocument", + "UpdateDocumentDefaultVersion", + "UpdateDocumentMetadata", + "UpdateMaintenanceWindow", + "UpdateMaintenanceWindowTarget", + "UpdateMaintenanceWindowTask", + "UpdateManagedInstanceRole", + "UpdateOpsItem", + "UpdateOpsMetadata", + "UpdatePatchBaseline", + "UpdateResourceDataSync", + "UpdateServiceSetting" + ] + }, + "ssoadmin": { + "protocol": "json-1.1", + "servedOps": [ + "AddRegion", + "AttachCustomerManagedPolicyReferenceToPermissionSet", + "AttachManagedPolicyToPermissionSet", + "CreateAccountAssignment", + "CreateApplication", + "CreateApplicationAssignment", + "CreateInstance", + "CreateInstanceAccessControlAttributeConfiguration", + "CreatePermissionSet", + "CreateTrustedTokenIssuer", + "DeleteAccountAssignment", + "DeleteApplication", + "DeleteApplicationAccessScope", + "DeleteApplicationAssignment", + "DeleteApplicationAuthenticationMethod", + "DeleteApplicationGrant", + "DeleteInlinePolicyFromPermissionSet", + "DeleteInstance", + "DeleteInstanceAccessControlAttributeConfiguration", + "DeletePermissionSet", + "DeletePermissionsBoundaryFromPermissionSet", + "DeleteTrustedTokenIssuer", + "DescribeAccountAssignmentCreationStatus", + "DescribeAccountAssignmentDeletionStatus", + "DescribeApplication", + "DescribeApplicationAssignment", + "DescribeApplicationProvider", + "DescribeInstance", + "DescribeInstanceAccessControlAttributeConfiguration", + "DescribePermissionSet", + "DescribePermissionSetProvisioningStatus", + "DescribeRegion", + "DescribeTrustedTokenIssuer", + "DetachCustomerManagedPolicyReferenceFromPermissionSet", + "DetachManagedPolicyFromPermissionSet", + "GetApplicationAccessScope", + "GetApplicationAssignmentConfiguration", + "GetApplicationAuthenticationMethod", + "GetApplicationGrant", + "GetApplicationSessionConfiguration", + "GetInlinePolicyForPermissionSet", + "GetPermissionsBoundaryForPermissionSet", + "ListAccountAssignmentCreationStatus", + "ListAccountAssignmentDeletionStatus", + "ListAccountAssignments", + "ListAccountAssignmentsForPrincipal", + "ListAccountsForProvisionedPermissionSet", + "ListApplicationAccessScopes", + "ListApplicationAssignments", + "ListApplicationAssignmentsForPrincipal", + "ListApplicationAuthenticationMethods", + "ListApplicationGrants", + "ListApplicationProviders", + "ListApplications", + "ListCustomerManagedPolicyReferencesInPermissionSet", + "ListInstances", + "ListManagedPoliciesInPermissionSet", + "ListPermissionSetProvisioningStatus", + "ListPermissionSets", + "ListPermissionSetsProvisionedToAccount", + "ListRegions", + "ListTagsForResource", + "ListTrustedTokenIssuers", + "ProvisionPermissionSet", + "PutApplicationAccessScope", + "PutApplicationAssignmentConfiguration", + "PutApplicationAuthenticationMethod", + "PutApplicationGrant", + "PutApplicationSessionConfiguration", + "PutInlinePolicyToPermissionSet", + "PutPermissionsBoundaryToPermissionSet", + "RemoveRegion", + "TagResource", + "UntagResource", + "UpdateApplication", + "UpdateInstance", + "UpdateInstanceAccessControlAttributeConfiguration", + "UpdatePermissionSet", + "UpdateTrustedTokenIssuer" + ] + }, + "sts": { + "protocol": "query", + "servedOps": [ + "AssumeRole", + "GetAccessKeyInfo", + "GetCallerIdentity", + "GetSessionToken" + ] + }, + "support": { + "protocol": "json-1.1", + "servedOps": [ + "AddAttachmentsToSet", + "AddCommunicationToCase", + "CreateCase", + "CreateSupportPlan", + "DeleteAttachmentSet", + "DescribeAttachment", + "DescribeAttachmentSet", + "DescribeCaseHistory", + "DescribeCases", + "DescribeCategories", + "DescribeCommunications", + "DescribeCreateCaseOptions", + "DescribeSecureCaseOperations", + "DescribeServiceHealth", + "DescribeServices", + "DescribeSeverityLevels", + "DescribeSupportLevel", + "DescribeSupportPlan", + "DescribeSupportedLanguages", + "DescribeTopicPaths", + "DescribeTopics", + "DescribeTrustedAdvisorCheckRefreshStatuses", + "DescribeTrustedAdvisorCheckResult", + "DescribeTrustedAdvisorCheckSummaries", + "DescribeTrustedAdvisorChecks", + "EscalateCase", + "GetOnboardingStatus", + "ListAttachments", + "ListCaseCategories", + "ListCases", + "ListSupportPlans", + "ListTagsForResource", + "ModifySecureCaseParameters", + "RefreshTrustedAdvisorCheck", + "ReopenCase", + "ResolveCase", + "SearchCases", + "StartOnboarding", + "TagResource", + "TransferCase", + "UntagResource", + "UpdateCaseAttributes", + "UpdateSupportPlan" + ] + }, + "swf": { + "protocol": "json-1.0", + "servedOps": [ + "CountClosedWorkflowExecutions", + "CountOpenWorkflowExecutions", + "CountPendingActivityTasks", + "CountPendingDecisionTasks", + "DeleteActivityType", + "DeleteWorkflowType", + "DeprecateActivityType", + "DeprecateDomain", + "DeprecateWorkflowType", + "DescribeActivityType", + "DescribeDomain", + "DescribeWorkflowExecution", + "DescribeWorkflowType", + "GetWorkflowExecutionHistory", + "ListActivityTypes", + "ListClosedWorkflowExecutions", + "ListDomains", + "ListOpenWorkflowExecutions", + "ListTagsForResource", + "ListWorkflowTypes", + "PollForActivityTask", + "PollForDecisionTask", + "RecordActivityTaskHeartbeat", + "RegisterActivityType", + "RegisterDomain", + "RegisterWorkflowType", + "RequestCancelWorkflowExecution", + "RespondActivityTaskCanceled", + "RespondActivityTaskCompleted", + "RespondActivityTaskFailed", + "RespondDecisionTaskCompleted", + "SignalWorkflowExecution", + "StartWorkflowExecution", + "TagResource", + "TerminateWorkflowExecution", + "UndeprecateActivityType", + "UndeprecateDomain", + "UndeprecateWorkflowType", + "UntagResource" + ] + }, + "synthetics": { + "protocol": "rest-json", + "servedOps": [ + "CreateCanary", + "CreateGroup", + "DeleteCanary", + "DeleteGroup", + "DescribeCanaries", + "DescribeCanariesLastRun", + "DescribeRuntimeVersions", + "GetCanary", + "GetCanaryRuns", + "GetGroup", + "ListAssociatedGroups", + "ListGroupResources", + "ListGroups", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateCanary" + ] + }, + "textract": { + "protocol": "json-1.1", + "servedOps": [ + "AnalyzeDocument", + "AnalyzeExpense", + "AnalyzeID", + "CancelJob", + "CreateAdapter", + "CreateAdapterVersion", + "DeleteAdapter", + "DeleteAdapterVersion", + "DescribeAdapter", + "DescribeAdapterVersion", + "DescribeServiceQuotas", + "DetectDocumentText", + "GetAdapter", + "GetAdapterVersion", + "GetAnalyzeDocumentJobResults", + "GetDetectDominantLanguagesJobResults", + "GetDocumentAnalysis", + "GetDocumentTextDetection", + "GetEntitiesDetectionJobResults", + "GetExpenseAnalysis", + "GetKeyValuesDetectionJobResults", + "GetLabelDetectionJobResults", + "GetLendingAnalysis", + "GetLendingAnalysisSummary", + "GetServiceStatus", + "ListAdapterJobs", + "ListAdapterVersions", + "ListAdapters", + "ListFeedback", + "ListJobs", + "ListTagsForResource", + "StartAdapterTraining", + "StartDetectDominantLanguages", + "StartDocumentAnalysis", + "StartDocumentTextDetection", + "StartDocumentTextDetectionV2", + "StartEntitiesDetection", + "StartExpenseAnalysis", + "StartKeyValuesDetection", + "StartLabelDetection", + "StartLendingAnalysis", + "StopAdapterTraining", + "SubmitFeedback", + "TagResource", + "UntagResource", + "UpdateAdapter" + ] + }, + "timestreaminfluxdb": { + "protocol": "json-1.0", + "servedOps": [ + "CreateDbBackup", + "CreateDbCluster", + "CreateDbInstance", + "CreateDbParameterGroup", + "DeleteDbBackup", + "DeleteDbCluster", + "DeleteDbInstance", + "GetDbBackup", + "GetDbCluster", + "GetDbInstance", + "GetDbParameterGroup", + "ListDbBackups", + "ListDbClusters", + "ListDbInstances", + "ListDbInstancesForCluster", + "ListDbParameterGroups", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateDbCluster", + "UpdateDbInstance" + ] + }, + "timestreamquery": { + "protocol": "json-1.0", + "servedOps": [ + "CreateScheduledQuery", + "DeleteScheduledQuery", + "DescribeAccountSettings", + "DescribeEndpoints", + "DescribeScheduledQuery", + "ListScheduledQueries", + "ListTagsForResource", + "TagResource", + "UntagResource", + "UpdateAccountSettings", + "UpdateScheduledQuery" + ] + }, + "timestreamwrite": { + "protocol": "json-1.0", + "servedOps": [ + "CreateBatchLoadTask", + "CreateDatabase", + "CreateTable", + "DeleteDatabase", + "DeleteTable", + "DescribeBatchLoadTask", + "DescribeDatabase", + "DescribeEndpoints", + "DescribeTable", + "ListBatchLoadTasks", + "ListDatabases", + "ListTables", + "ListTagsForResource", + "ResumeBatchLoadTask", + "TagResource", + "UntagResource", + "UpdateDatabase", + "UpdateTable", + "WriteRecords" + ] + }, + "transcribe": { + "protocol": "json-1.1", + "servedOps": [ + "CreateCallAnalyticsCategory", + "CreateLanguageModel", + "CreateMedicalVocabulary", + "CreateVocabulary", + "CreateVocabularyFilter", + "DeleteCallAnalyticsCategory", + "DeleteCallAnalyticsJob", + "DeleteLanguageModel", + "DeleteMedicalScribeJob", + "DeleteMedicalTranscriptionJob", + "DeleteMedicalVocabulary", + "DeleteTranscriptionJob", + "DeleteVocabulary", + "DeleteVocabularyFilter", + "DescribeLanguageModel", + "GetCallAnalyticsCategory", + "GetCallAnalyticsJob", + "GetMedicalScribeJob", + "GetMedicalTranscriptionJob", + "GetMedicalVocabulary", + "GetTranscriptionJob", + "GetVocabulary", + "GetVocabularyFilter", + "ListCallAnalyticsCategories", + "ListCallAnalyticsJobs", + "ListLanguageModels", + "ListMedicalScribeJobs", + "ListMedicalTranscriptionJobs", + "ListMedicalVocabularies", + "ListTagsForResource", + "ListTranscriptionJobs", + "ListVocabularies", + "ListVocabularyFilters", + "StartCallAnalyticsJob", + "StartMedicalScribeJob", + "StartMedicalTranscriptionJob", + "StartTranscriptionJob", + "TagResource", + "UntagResource", + "UpdateCallAnalyticsCategory", + "UpdateMedicalVocabulary", + "UpdateVocabulary", + "UpdateVocabularyFilter" + ] + }, + "transcribestreaming": { + "protocol": "rest-json", + "servedOps": [ + "GetMedicalScribeStream" + ] + }, + "transfer": { + "protocol": "json-1.1", + "servedOps": [ + "CreateAccess", + "CreateAgreement", + "CreateConnector", + "CreateProfile", + "CreateServer", + "CreateUser", + "CreateWebApp", + "CreateWorkflow", + "DeleteAccess", + "DeleteAgreement", + "DeleteCertificate", + "DeleteConnector", + "DeleteHostKey", + "DeleteProfile", + "DeleteServer", + "DeleteSshPublicKey", + "DeleteUser", + "DeleteWebApp", + "DeleteWebAppCustomization", + "DeleteWorkflow", + "DescribeAccess", + "DescribeAgreement", + "DescribeCertificate", + "DescribeConnector", + "DescribeExecution", + "DescribeHostKey", + "DescribeProfile", + "DescribeSecurityPolicy", + "DescribeServer", + "DescribeUser", + "DescribeWebApp", + "DescribeWebAppCustomization", + "DescribeWorkflow", + "ImportHostKey", + "ImportSshPublicKey", + "ListAccesses", + "ListAgreements", + "ListCertificates", + "ListConnectors", + "ListExecutions", + "ListFileTransferResults", + "ListHostKeys", + "ListProfiles", + "ListSecurityPolicies", + "ListServers", + "ListTagsForResource", + "ListUsers", + "ListWebApps", + "ListWorkflows", + "SendWorkflowStepState", + "StartDirectoryListing", + "StartFileTransfer", + "StartRemoteDelete", + "StartRemoteMove", + "StartServer", + "StopServer", + "TagResource", + "TestConnection", + "TestIdentityProvider", + "UntagResource", + "UpdateAccess", + "UpdateAgreement", + "UpdateCertificate", + "UpdateConnector", + "UpdateHostKey", + "UpdateProfile", + "UpdateServer", + "UpdateUser", + "UpdateWebApp", + "UpdateWebAppCustomization" + ] + }, + "translate": { + "protocol": "json-1.1", + "servedOps": [ + "CreateParallelData", + "DeleteParallelData", + "DeleteTerminology", + "DescribeTextTranslationJob", + "GetParallelData", + "GetTerminology", + "ListLanguages", + "ListParallelData", + "ListTagsForResource", + "ListTerminologies", + "ListTextTranslationJobs", + "TagResource", + "UntagResource", + "UpdateParallelData" + ] + }, + "verifiedpermissions": { + "protocol": "", + "servedOps": [ + "BatchEvaluatePermissions", + "BatchGetEntityRelationship", + "CreateEntityRelationship", + "CreateIdentityPool", + "CreatePermission", + "CreatePermissionGroup", + "CreatePolicy", + "CreatePolicyTemplate", + "CreateSchema", + "DeleteEntityRelationship", + "DeleteIdentityPool", + "DeletePermission", + "DeletePermissionGroup", + "DeletePolicy", + "DeletePolicyTemplate", + "DeleteSchema", + "GetIdentityPool", + "GetPermission", + "GetPermissionGroup", + "GetPermissionsPolicy", + "GetPolicy", + "GetPolicyTemplate", + "GetSchema", + "IsAuthorized", + "ListEntityRelationships", + "ListIdentityPools", + "ListPermissionGroups", + "ListPermissions", + "ListPolicies", + "ListPolicyTemplates", + "ListSchemaReaders", + "ListSchemaWriters", + "PutPermissionsPolicy", + "PutPolicy", + "PutPolicyTemplate", + "PutSchema" + ] + }, + "voiceid": { + "protocol": "json-1.0", + "servedOps": [ + "CreateDomain", + "CreateWatchlist", + "DeleteDomain", + "DeleteFraudster", + "DeleteSpeaker", + "DeleteWatchlist", + "DescribeDomain", + "DescribeFraudster", + "DescribeFraudsterRegistrationJob", + "DescribeSpeaker", + "DescribeSpeakerEnrollmentJob", + "DescribeWatchlist", + "ListDomains", + "ListFraudsterRegistrationJobs", + "ListFraudsters", + "ListSpeakerEnrollmentJobs", + "ListSpeakers", + "ListTagsForResource", + "ListWatchlists", + "TagResource", + "UntagResource", + "UpdateDomain", + "UpdateWatchlist" + ] + }, + "vpclattice": { + "protocol": "rest-json", + "servedOps": [ + "CreateAccessLogSubscription", + "CreateListener", + "CreateResourceConfiguration", + "CreateResourceGateway", + "CreateRule", + "CreateService", + "CreateServiceNetwork", + "CreateServiceNetworkResourceAssociation", + "CreateServiceNetworkServiceAssociation", + "CreateServiceNetworkVpcAssociation", + "CreateTargetGroup", + "DeleteAccessLogSubscription", + "DeleteAuthPolicy", + "DeleteDomainVerification", + "DeleteListener", + "DeleteResourceConfiguration", + "DeleteResourceEndpointAssociation", + "DeleteResourceGateway", + "DeleteResourcePolicy", + "DeleteRule", + "DeleteService", + "DeleteServiceNetwork", + "DeleteServiceNetworkResourceAssociation", + "DeleteServiceNetworkServiceAssociation", + "DeleteServiceNetworkVpcAssociation", + "DeleteTargetGroup", + "DeregisterTargets", + "GetAccessLogSubscription", + "GetAuthPolicy", + "GetDomainVerification", + "GetListener", + "GetResourceConfiguration", + "GetResourceGateway", + "GetResourcePolicy", + "GetRule", + "GetService", + "GetServiceNetwork", + "GetServiceNetworkResourceAssociation", + "GetServiceNetworkServiceAssociation", + "GetServiceNetworkVpcAssociation", + "GetTargetGroup", + "ListAccessLogSubscriptions", + "ListDomainVerifications", + "ListListeners", + "ListResourceConfigurations", + "ListResourceEndpointAssociations", + "ListResourceGateways", + "ListRules", + "ListServiceNetworkResourceAssociations", + "ListServiceNetworkServiceAssociations", + "ListServiceNetworkVpcAssociations", + "ListServiceNetworkVpcEndpointAssociations", + "ListServiceNetworks", + "ListServices", + "ListTagsForResource", + "ListTargetGroups", + "ListTargets", + "PutAuthPolicy", + "PutResourcePolicy", + "RegisterTargets", + "TagResource", + "UntagResource", + "UpdateAccessLogSubscription", + "UpdateListener", + "UpdateResourceConfiguration", + "UpdateResourceGateway", + "UpdateRule", + "UpdateService", + "UpdateServiceNetwork", + "UpdateServiceNetworkVpcAssociation", + "UpdateTargetGroup" + ] + }, + "waf": { + "protocol": "json-1.1", + "servedOps": [ + "CreateByteMatchSet", + "CreateGeoMatchSet", + "CreateIPSet", + "CreateRateBasedRule", + "CreateRegexMatchSet", + "CreateRegexPatternSet", + "CreateRule", + "CreateRuleGroup", + "CreateSizeConstraintSet", + "CreateSqlInjectionMatchSet", + "CreateWebACL", + "CreateWebACLMigrationStack", + "CreateXssMatchSet", + "DeleteByteMatchSet", + "DeleteGeoMatchSet", + "DeleteIPSet", + "DeleteLoggingConfiguration", + "DeletePermissionPolicy", + "DeleteRateBasedRule", + "DeleteRegexMatchSet", + "DeleteRegexPatternSet", + "DeleteRule", + "DeleteRuleGroup", + "DeleteSizeConstraintSet", + "DeleteSqlInjectionMatchSet", + "DeleteWebACL", + "DeleteXssMatchSet", + "GetByteMatchSet", + "GetChangeToken", + "GetChangeTokenStatus", + "GetGeoMatchSet", + "GetIPSet", + "GetLoggingConfiguration", + "GetPermissionPolicy", + "GetRateBasedRule", + "GetRateBasedRuleManagedKeys", + "GetRegexMatchSet", + "GetRegexPatternSet", + "GetRule", + "GetRuleGroup", + "GetSampledRequests", + "GetSizeConstraintSet", + "GetSqlInjectionMatchSet", + "GetWebACL", + "GetXssMatchSet", + "ListActivatedRulesInRuleGroup", + "ListByteMatchSets", + "ListGeoMatchSets", + "ListIPSets", + "ListLoggingConfigurations", + "ListRateBasedRules", + "ListRegexMatchSets", + "ListRegexPatternSets", + "ListRuleGroups", + "ListRules", + "ListSizeConstraintSets", + "ListSqlInjectionMatchSets", + "ListSubscribedRuleGroups", + "ListTagsForResource", + "ListWebACLs", + "ListXssMatchSets", + "PutLoggingConfiguration", + "PutPermissionPolicy", + "TagResource", + "UntagResource", + "UpdateByteMatchSet", + "UpdateGeoMatchSet", + "UpdateIPSet", + "UpdateRateBasedRule", + "UpdateRegexMatchSet", + "UpdateRegexPatternSet", + "UpdateRule", + "UpdateRuleGroup", + "UpdateSizeConstraintSet", + "UpdateSqlInjectionMatchSet", + "UpdateWebACL", + "UpdateXssMatchSet" + ] + }, + "wafv2": { + "protocol": "json-1.1", + "servedOps": [ + "AssociateWebACL", + "CheckCapacity", + "CreateAPIKey", + "CreateIPSet", + "CreateRegexPatternSet", + "CreateRuleGroup", + "CreateWebACL", + "DeleteAPIKey", + "DeleteFirewallManagerRuleGroups", + "DeleteIPSet", + "DeleteLoggingConfiguration", + "DeletePermissionPolicy", + "DeleteRegexPatternSet", + "DeleteRuleGroup", + "DeleteWebACL", + "DescribeAllManagedProducts", + "DescribeManagedProductsByVendor", + "DescribeManagedRuleGroup", + "DisassociateWebACL", + "GetDecryptedAPIKey", + "GetIPSet", + "GetLoggingConfiguration", + "GetManagedRuleSet", + "GetMobileSdkRelease", + "GetPermissionPolicy", + "GetRateBasedStatementManagedKeys", + "GetRegexPatternSet", + "GetRuleGroup", + "GetSampledRequests", + "GetTopPathStatisticsByTraffic", + "GetWebACL", + "GetWebACLForResource", + "ListAPIKeys", + "ListAvailableManagedRuleGroupVersions", + "ListAvailableManagedRuleGroups", + "ListIPSets", + "ListLoggingConfigurations", + "ListManagedRuleSets", + "ListMobileSdkReleases", + "ListRegexPatternSets", + "ListResourcesForWebACL", + "ListRuleGroups", + "ListTagsForResource", + "ListWebACLs", + "PutLoggingConfiguration", + "PutManagedRuleSetVersions", + "PutPermissionPolicy", + "TagResource", + "UntagResource", + "UpdateIPSet", + "UpdateManagedRuleSetVersionExpiryDate", + "UpdateRegexPatternSet", + "UpdateRuleGroup", + "UpdateWebACL" + ] + }, + "workspaces": { + "protocol": "json-1.1", + "servedOps": [ + "CreateAccountLinkInvitation", + "CreateConnectClientAddIn", + "CreateConnectionAlias", + "CreateIpGroup", + "CreateStandbyWorkspaces", + "CreateTags", + "CreateUpdatedWorkspaceImage", + "CreateWorkspaceBundle", + "CreateWorkspaceImage", + "CreateWorkspaces", + "CreateWorkspacesPool", + "DeleteAccountLinkInvitation", + "DeleteClientBranding", + "DeleteConnectClientAddIn", + "DeleteConnectionAlias", + "DeleteIpGroup", + "DeleteTags", + "DeleteWorkspaceBundle", + "DeleteWorkspaceImage", + "DeregisterWorkspaceDirectory", + "DescribeAccount", + "DescribeAccountModifications", + "DescribeApplicationAssociations", + "DescribeApplications", + "DescribeBundleAssociations", + "DescribeClientBranding", + "DescribeClientProperties", + "DescribeConnectClientAddIns", + "DescribeConnectionAliasPermissions", + "DescribeConnectionAliases", + "DescribeCustomWorkspaceImageImport", + "DescribeImageAssociations", + "DescribeIpGroups", + "DescribeTags", + "DescribeWorkspaceAssociations", + "DescribeWorkspaceBundles", + "DescribeWorkspaceDirectories", + "DescribeWorkspaceImagePermissions", + "DescribeWorkspaceImages", + "DescribeWorkspaceSnapshots", + "DescribeWorkspaces", + "DescribeWorkspacesConnectionStatus", + "DescribeWorkspacesPoolSessions", + "DescribeWorkspacesPools", + "GetAccountLink", + "ListAccountLinks", + "ListAvailableManagementCidrRanges", + "ModifyAccount", + "ModifyCertificateBasedAuthProperties", + "ModifyClientProperties", + "ModifyEndpointEncryptionMode", + "ModifySamlProperties", + "ModifySelfservicePermissions", + "ModifyStreamingProperties", + "ModifyWorkspaceAccessProperties", + "ModifyWorkspaceCreationProperties", + "ModifyWorkspaceProperties", + "ModifyWorkspaceState", + "RegisterWorkspaceDirectory", + "UpdateConnectClientAddIn", + "UpdateConnectionAliasPermission", + "UpdateRulesOfIpGroup", + "UpdateWorkspaceBundle", + "UpdateWorkspaceImagePermission", + "UpdateWorkspacesPool" + ] + }, + "workspacesweb": { + "protocol": "rest-json", + "servedOps": [ + "CreateBrowserSettings", + "CreateDataProtectionSettings", + "CreateIdentityProvider", + "CreateIpAccessSettings", + "CreateNetworkSettings", + "CreatePortal", + "CreateSessionLogger", + "CreateTrustStore", + "CreateUserAccessLoggingSettings", + "CreateUserSettings", + "DeleteBrowserSettings", + "DeleteDataProtectionSettings", + "DeleteIdentityProvider", + "DeleteIpAccessSettings", + "DeleteNetworkSettings", + "DeletePortal", + "DeleteSessionLogger", + "DeleteTrustStore", + "DeleteUserAccessLoggingSettings", + "DeleteUserSettings", + "GetBrowserSettings", + "GetDataProtectionSettings", + "GetIdentityProvider", + "GetIpAccessSettings", + "GetNetworkSettings", + "GetPortal", + "GetPortalServiceProviderMetadata", + "GetSession", + "GetSessionLogger", + "GetTrustStore", + "GetTrustStoreCertificate", + "GetUserAccessLoggingSettings", + "GetUserSettings", + "ListBrowserSettings", + "ListDataProtectionSettings", + "ListIdentityProviders", + "ListIpAccessSettings", + "ListNetworkSettings", + "ListPortals", + "ListSessionLoggers", + "ListSessions", + "ListTagsForResource", + "ListTrustStoreCertificates", + "ListTrustStores", + "ListUserAccessLoggingSettings", + "ListUserSettings", + "TagResource", + "UntagResource", + "UpdateBrowserSettings", + "UpdateDataProtectionSettings", + "UpdateIdentityProvider", + "UpdateIpAccessSettings", + "UpdateNetworkSettings", + "UpdatePortal", + "UpdateSessionLogger", + "UpdateTrustStore", + "UpdateUserAccessLoggingSettings", + "UpdateUserSettings" + ] + }, + "xray": { + "protocol": "rest-json", + "servedOps": [ + "BatchGetTraces", + "CreateGroup", + "CreateSamplingRule", + "DeleteGroup", + "DeleteResourcePolicy", + "DeleteSamplingRule", + "GetEncryptionConfig", + "GetGroup", + "GetGroups", + "GetInsight", + "GetInsightEvents", + "GetInsightImpactGraph", + "GetInsightSummaries", + "GetResourcePolicy", + "GetSamplingRules", + "GetSamplingStatisticSummaries", + "GetSamplingTargets", + "GetServiceGraph", + "GetTimeSeriesServiceStatistics", + "GetTraceGraph", + "GetTraceSummaries", + "ListResourcePolicies", + "ListTagsForResource", + "PutEncryptionConfig", + "PutResourcePolicy", + "PutTelemetryRecords", + "PutTraceSegments", + "TagResource", + "UntagResource", + "UpdateGroup", + "UpdateSamplingRule" + ] + } +} diff --git a/tests/compatibility/_coverage.py b/tests/compatibility/_coverage.py new file mode 100644 index 00000000..8e3dc563 --- /dev/null +++ b/tests/compatibility/_coverage.py @@ -0,0 +1,284 @@ +"""Resolves the generated service manifest into things boto3 can be asked. + +The compatibility suite used to carry two hand-written lists of service names. +A service could therefore be registered, counted in the published coverage +figure, and exercised by no test at all — which is what 31 of 205 registered +services were. This module removes the hand-written step: the fleet comes from +``internal/generated/compat/services.json``, which codegen derives from the same +fidelity manifest ``docs/coverage.md`` publishes its numbers from. + +Three things have to be resolved per service, and each is resolved from data +rather than from a list someone remembered to update: + +1. **Which boto3 client name reaches it.** DevCloud service IDs and boto3 client + names are different vocabularies (``cloudwatchlogs`` vs ``logs``, + ``costexplorer`` vs ``ce``). botocore's own model metadata is the bridge. +2. **Which operation to ask for.** Taken from the manifest's served set, so the + suite never asks a service for an operation the manifest already calls + unimplemented and then reports the honest failure as a broken service. +3. **What to pass it.** Most services declare a read that needs no input; 27 do + not, and for those a stub is built from the operation's own input shape. +""" + +import datetime +import json +import pathlib + +import botocore.session + +MANIFEST_PATH = ( + pathlib.Path(__file__).resolve().parents[2] + / "internal" + / "generated" + / "compat" + / "services.json" +) + +# Service IDs whose boto3 client name cannot be derived, and why. +# +# The rule below refuses a contested name rather than guessing, mirroring +# codegen.BuildAliases: picking silently would test one service through another +# service's client and report the result under the wrong name. +# +# elasticloadbalancing is the only contested case in the fleet. ELB v1 and v2 +# share the "elasticloadbalancing" endpoint prefix and signing name, and botocore +# splits them into two clients, so the prefix names both. v1 is "elb". +BOTO3_NAME_OVERRIDES = { + "elasticloadbalancing": "elb", +} + +# Registered services no boto3 caller can reach, so no boto3 test can exist for +# them. botocore publishes 431 clients and neither of these is among them — +# "sagemaker-runtime" and "transcribe" are different clients with different APIs. +# +# This is the ceiling on the compatibility-tested figure in docs/coverage.md, and +# it is a property of the AWS SDK rather than of DevCloud. Both services stay +# registered: a registered service answers locally in AWS's error vocabulary, +# which is the whole reason registering something DevCloud cannot serve beats +# leaving the call to reach a billed AWS account. +NO_BOTO3_CLIENT = { + "sagemakerruntimehttp2": "botocore has no HTTP/2 SageMaker Runtime client", + "transcribestreaming": "botocore has no streaming Transcribe client", +} + +# Registered, counted as serving operations, and reachable by no boto3 caller. +# +# All four Lex clients sign as "lex" and none of the four services is called +# "lex", so codegen.BuildAliases leaves the name contested and unrouted — by +# design, because guessing would send one service's traffic to another. The +# consequence docs/coverage.md did not state until this was measured: the +# "reached by its own unambiguous name" escape does not exist for a boto3 +# caller, because boto3 signs with the contested name and nothing else. +# +# Splitting them on the URL is what resolved opensearch/elasticsearchservice and +# apigateway v1/v2, and it does not work here: /bots is the first segment for +# lex-model-building-service, lex-models-v2 AND lex-runtime-v2. A correct split +# needs full path matching across four services, which is routing work rather +# than coverage work. +# +# Pinned by test_lex_services_are_unreachable_from_boto3 so that fixing the +# routing fails this test and forces the published figure up with it. +UNREACHABLE_FROM_BOTO3 = { + "lexmodelbuildingservice": "signs as the contested alias 'lex'", + "lexmodelsv2": "signs as the contested alias 'lex'", + "lexruntimeservice": "signs as the contested alias 'lex'", + "lexruntimev2": "signs as the contested alias 'lex'", +} + +# A resource that does not exist in an empty store is a served answer: the engine +# looked in the store and reported honestly. +SERVED_ERROR_CODES = { + "ResourceNotFoundException", + "NotFoundException", + "ResourceNotFound", + "NoSuchEntity", +} + +# Codes that mean nothing handled the request. UnknownService is the registry +# miss in internal/gateway/router.go; InvalidAction is a routed service refusing +# an operation the engine could not classify. Either one under a service the +# manifest says serves something is a wiring defect. +UNSERVED_ERROR_CODES = { + "UnknownService", + "InvalidAction", + "NotImplemented", +} + + +def load_manifest(): + """Return the generated service manifest, keyed by DevCloud service ID.""" + with MANIFEST_PATH.open() as fh: + return json.load(fh) + + +def _botocore_index(session): + """Index botocore's clients by every name a model publishes for them. + + A name claimed by more than one client is dropped rather than resolved. The + only one that matters today is "elasticloadbalancing", claimed by elb and + elbv2; BOTO3_NAME_OVERRIDES carries its resolution. + """ + available = set(session.get_available_services()) + + bare = {} + for name in available: + bare.setdefault(name.replace("-", ""), set()).add(name) + + claims = {} + for name in available: + try: + metadata = session.get_service_model(name).metadata + except ( + Exception + ): # a model botocore ships but cannot load is not a client we can test + continue + for key in ( + metadata.get("endpointPrefix"), + metadata.get("signingName"), + metadata.get("serviceId"), + metadata.get("targetPrefix"), + ): + if key: + normalized = key.lower().replace(" ", "").replace("-", "") + claims.setdefault(normalized, set()).add(name) + + return available, bare, claims + + +_SESSION = botocore.session.get_session() +_AVAILABLE, _BARE, _CLAIMS = _botocore_index(_SESSION) + + +def boto3_name(service_id): + """Return the boto3 client name for a DevCloud service ID, or None. + + None means no boto3 caller can address the service. Every such case is in + NO_BOTO3_CLIENT with a reason; anything else returning None is a resolution + gap and test_every_registered_service_is_addressable fails on it. + """ + if service_id in BOTO3_NAME_OVERRIDES: + return BOTO3_NAME_OVERRIDES[service_id] + if service_id in _AVAILABLE: + return service_id + + bare = service_id.replace("-", "") + for index in (_BARE, _CLAIMS): + candidates = index.get(bare, set()) + if len(candidates) == 1: + return next(iter(candidates)) + return None + + +def service_model(name): + """Return botocore's model for a client name.""" + return _SESSION.get_service_model(name) + + +# How many operations to try before calling a service unserved. The floor is +# "at least one served operation answers", so one success is enough and one +# failure is not a verdict — the manifest can be right about a service and wrong +# about a particular operation, which is exactly what appsync/ListApis, +# eks/ListAccessPolicies, opensearch/ListApplications and +# neptune/DescribeDBClusterEndpoints turned out to be. +PROBE_LIMIT = 6 + + +def probe_operations(boto3_client_name, served_ops): + """Return operations to try, best first, as ``(operation, needs_input)``. + + Empty when the service serves nothing at all, which is the decline case. + + Reads are preferred over writes, and within reads a List is preferred over a + Describe: a List of an empty store returns an empty collection, while a + Describe of one absent resource correctly raises ResourceNotFoundException. + Both are served answers, but the List case is unambiguous. An operation + needing no input outranks all of them, because nothing about the request can + then be blamed on the values this module invented. + + Only operations the manifest reports as served are considered. Asking for an + unimplemented one would produce a correct refusal that reads as a defect. + """ + if not served_ops: + return [] + + model = service_model(boto3_client_name) + served = sorted(set(served_ops) & set(model.operation_names)) + if not served: + return [] + + def _required(op): + shape = model.operation_model(op).input_shape + return bool(shape is not None and shape.required_members) + + parameterless, with_input = [], [] + for prefix in ("List", "Describe", "Get"): + for op in served: + if not op.startswith(prefix): + continue + (with_input if _required(op) else parameterless).append((op, _required(op))) + + ordered = parameterless + with_input + if not ordered: + ordered = [(op, _required(op)) for op in served] + return ordered[:PROBE_LIMIT] + + +def stub_params(boto3_client_name, operation): + """Build the smallest input botocore will accept for an operation. + + Only required members, typed from the shape. The values are meaningless on + purpose: the assertion these feed proves a request was routed and its + operation classified, never that the answer is correct. A service that + rejects the values with an AWS error code has already proved both. + """ + shape = service_model(boto3_client_name).operation_model(operation).input_shape + if shape is None: + return {} + return _stub_structure(shape, depth=0) + + +def _stub_structure(shape, depth): + return { + name: _stub_value(shape.members[name], depth + 1) + for name in shape.required_members + } + + +def _stub_value(shape, depth): + kind = shape.type_name + if kind == "structure": + # Depth-limited: a self-referential shape would otherwise recurse + # forever, and botocore does not validate members below what it was + # given anyway. + if depth > 4: + return {} + return _stub_structure(shape, depth) + if kind == "list": + # botocore validates minimum collection length client-side, so an empty + # list never leaves the process for a shape that requires members — + # which reads as a service defect when it is a harness one. + minimum = shape.metadata.get("min", 0) + if minimum: + return [_stub_value(shape.member, depth + 1) for _ in range(minimum)] + return [] + if kind == "map": + minimum = shape.metadata.get("min", 0) + if minimum: + return { + f"devcloud-test-{i}": _stub_value(shape.value, depth + 1) + for i in range(minimum) + } + return {} + if kind == "blob": + return b"" + if kind == "boolean": + return False + if kind in ("integer", "long"): + return 1 + if kind in ("float", "double"): + return 1.0 + if kind == "timestamp": + return datetime.datetime(2020, 1, 1) + # Strings, including enums: botocore does not validate enum members + # client-side, so an arbitrary value reaches the gateway, which is the point. + return "devcloud-test" diff --git a/tests/compatibility/test_service_smoke.py b/tests/compatibility/test_service_smoke.py index bd52cb5f..a7cb14d1 100644 --- a/tests/compatibility/test_service_smoke.py +++ b/tests/compatibility/test_service_smoke.py @@ -1,258 +1,238 @@ -"""Smoke coverage for services served by the generic CRUD engine. +"""Every registered service is asked something, and answers as AWS would. -A scaffolded service is registered and routed the moment it is generated, which -is not the same as being served: it answers an operation only if its provider -hands the operation to the CRUD engine. This test is the difference between the -two. It fails for a service that is routed but returns an error for every -operation — the state every scaffolded service was in before the provider -template opted into the engine. +This file used to carry two hand-written lists of service names, and adding a +service to ``internal/services`` did not require adding it here. So 31 of 205 +registered services were exercised by no boto3 test at all — 29 of them counted +in the coverage figure ``docs/coverage.md`` publishes. The lists are gone: the +fleet is now ``internal/generated/compat/services.json``, which codegen derives +from the same fidelity manifest that figure comes from. -Adding a service means adding its name below, not writing a fixture. +The floor this proves is the PRD's, and it has two halves: + +1. A service the manifest says serves something must serve it — from a real + store, in AWS's vocabulary. +2. A service the manifest says serves nothing must decline with a clean AWS + error. Never a fabricated success, which would be worse than not registering + the service at all, because the caller would believe it. + +Which of the two applies is read from the manifest, not decided here. That is +what makes this file unable to drift from the published numbers. """ +import pathlib +import re + import pytest from botocore import xform_name -from botocore.exceptions import ClientError - -# Names below are boto3 client names, not DevCloud service IDs — the two differ -# for split-out services ("kendra-ranking" vs kendraranking). Using the boto3 -# name is the point: the test asserts what a user typing it actually gets. -# -# Services whose coverage comes from the generic CRUD engine rather than a -# hand-written provider. The engine reads every protocol DevCloud registers, -# each naming its operation somewhere different: awsJson1_0 / awsJson1_1 in the -# X-Amz-Target header, rest-json and rest-xml in the request method and path via -# the model's route table, query in the Action field of the form body. -ENGINE_SERVED_SERVICES = [ - "comprehend", - # rest-json, and the proof the engine reaches that protocol at all. All - # three sat in REGISTERED_ONLY_SERVICES until the engine learned to resolve - # an operation from the method and path; nothing about these three services - # changed, only what the engine can read. - "polly", - "qbusiness", - "codeguru-reviewer", - # rekognition could not be onboarded at all before the alias table was - # derived from the models: its X-Amz-Target prefix is RekognitionService, - # which no hand-written gateway clause covered, so every call came back - # UnknownService. It is here to prove that onboarding now costs zero - # hand-written routing lines, not only zero provider lines. - "rekognition", - # The rest of the AI/ML category that the engine can serve. bedrock, - # sagemaker, textract and transcribe are engine-served too but already have - # their own test files, so they are not repeated here. - # bedrock-data-automation-runtime is engine-served (4 operations in the - # manifest) but is absent here on purpose: every one of its operations takes - # required parameters, so this harness has no parameterless read to prove it - # with. The manifest is its record, not this list. - "comprehendmedical", - "forecast", - "frauddetector", - "healthlake", - "kendra", - "kendra-ranking", - "lookoutequipment", - "personalize", - "translate", - "voice-id", - # --- the demand set (Milestone 4) --- - # Every unregistered AWS service that two or more of moto, LocalStack and - # terraform-provider-aws had already built (docs/demand.md). 54 of the 57 - # serve at least one operation; these 51 are the ones this harness can - # prove, because they declare a List*/Describe* that needs no input. - "amp", - "appmesh", - "cleanrooms", - "cloudhsmv2", - "codestar-connections", - "connect", - "databrew", - "datapipeline", - "datasync", - "dax", - "devops-agent", - "directconnect", - "ds", - "dsql", - "emr-containers", - "emr-serverless", - "fsx", - "greengrass", - "guardduty", - "inspector2", - "ivs", - "kinesisanalytics", - "kinesisvideo", - "macie2", - "mediaconnect", - "medialive", - "mediapackage", - "mediapackagev2", - "mediastore", - "mediastore-data", - "network-firewall", - "networkmanager", - "opensearchserverless", - "osis", - "payment-cryptography", - "quicksight", - "redshift-data", - "resiliencehub", - "route53domains", - "s3vectors", - "securityhub", - "service-quotas", - "servicecatalog", - "servicecatalog-appregistry", - "signer", - "synthetics", - "timestream-influxdb", - "timestream-query", - "vpc-lattice", - "workspaces", - "workspaces-web", - # --- the non-JSON surface (Milestone 5) --- - # The last two of the 57, and the reason they were last. Neither protocol - # names its operation the way the engine originally required: elb is query, - # so the operation is the Action field of a form body, and s3control is - # rest-xml, so it comes from the method and path. Both are read now, and - # this entry is what proves it against a real botocore parser rather than - # against Go's idea of the wire format. - # - # s3control is served too — 94 auto-crud operations in the manifest — but - # is absent here on purpose: every one of its 97 operations takes a required - # AccountId, so this harness has no parameterless read to prove it with. The - # budgets precedent, and tests/compatibility/test_s3control.py is where it - # is proved instead. - "elb", - # Served, but not provable here: apigateway and apigatewaymanagementapi - # read with Get* rather than List*/Describe*, and budgets requires an - # account id on every operation. The fidelity manifest is their record, - # as for bedrock-data-automation-runtime. -] +from botocore.exceptions import ClientError, ParamValidationError + +import _coverage + +MANIFEST = _coverage.load_manifest() -# Services registered so the gateway routes them, but served by nothing: no -# operation in their whole API is CRUD-shaped, and no provider implements them -# by hand. They must answer with a clean AWS error — never a fabricated success, and never an unrouted UnknownService, which would -# send a caller back to real AWS. They are deliberately NOT counted as covered; -# see docs/coverage.md. -# -# The protocol reason for being on this list is gone. The engine reads all five -# protocols now — X-Amz-Target for the JSON family, method and path for the two -# REST ones, the Action form field for query — so what is left here is only the -# services whose operations are not CRUD-shaped at all. -# -# personalize-runtime left this list when the engine gained rest-json: -# GetRecommendations classifies as a Get, so it is served now. It is not in -# ENGINE_SERVED_SERVICES either, because both its operations take required -# parameters and this harness has no parameterless read to prove it with — the -# fidelity manifest is its record, as for bedrock-data-automation-runtime. -REGISTERED_ONLY_SERVICES = [ - # rest-json, so the engine can read its requests — and still served by - # nothing, because it has no CRUD-shaped operation. InvokeEndpoint, - # InvokeEndpointAsync and InvokeEndpointWithResponseStream are not - # Create/Get/List/Delete/Update, so codegen registers nothing and there is - # no route to match. Same case as forecastquery. - "sagemaker-runtime", - # --- the demand set (Milestone 4) --- - # One of the 57 does not meet the floor. elb and s3control were here too, - # for the protocol reason Milestone 5 removed: the engine now reads query - # from the Action form field and rest-xml from the method and path. - # rds-data rest-json and readable, but its whole API is - # ExecuteStatement / BeginTransaction / Commit / Rollback, - # none of which is CRUD-shaped. No protocol change helps it, - # which is why it is the one that stays. - "rds-data", +# Sorted so a failure reads the same way on every machine and in every CI run. +ALL_SERVICES = sorted(MANIFEST) +ADDRESSABLE_SERVICES = [s for s in ALL_SERVICES if s not in _coverage.NO_BOTO3_CLIENT] +TESTABLE_SERVICES = [ + s for s in ADDRESSABLE_SERVICES if s not in _coverage.UNREACHABLE_FROM_BOTO3 ] -def _parameterless_read_op(client): - """Return a List*/Describe* operation that needs no input. +def _call(client, operation, params): + return getattr(client, xform_name(operation))(**params) - Picking the operation from the service model rather than hardcoding one per - service is what keeps this test from growing a branch per service. - List* is tried before Describe* because the two answer differently on an - empty store. A List returns an empty collection; a Describe of a single - resource correctly returns ResourceNotFoundException, which is the engine - working, not the engine missing. Preferring List keeps the common case - unambiguous — see _served_or_missing for the Describe-only services. +def test_every_registered_service_is_addressable(): + """Every registered service resolves to a boto3 client, or is a named case. + + This is the gate that keeps the parametrization below honest. Without it a + service whose name stopped resolving would silently drop out of the suite — + the exact failure mode the hand-written lists had, reintroduced by accident. """ - model = client.meta.service_model - for prefix in ("List", "Describe"): - for name in sorted(model.operation_names): - if not name.startswith(prefix): - continue - shape = model.operation_model(name).input_shape - if shape is None or not shape.required_members: - return name - return None - - -# A resource that does not exist in an empty store is a served answer: the -# engine looked in the store and reported honestly. A refusal is different — -# InvalidAction and NotImplemented mean nothing handled the request at all. -SERVED_ERROR_CODES = { - "ResourceNotFoundException", - "NotFoundException", - "ResourceNotFound", - "NoSuchEntity", -} - - -@pytest.mark.parametrize("service", ENGINE_SERVED_SERVICES) -def test_service_serves_at_least_one_operation(service_client, service): - client = service_client(service) - - op = _parameterless_read_op(client) - assert op is not None, ( - f"{service} declares no parameterless List*/Describe* operation, " - "so this test cannot establish that it serves anything" + unresolved = [ + service + for service in ADDRESSABLE_SERVICES + if _coverage.boto3_name(service) is None + ] + assert not unresolved, ( + f"{len(unresolved)} registered services resolve to no boto3 client name: " + f"{unresolved}. Either botocore renamed the client — add the resolution to " + "_coverage.BOTO3_NAME_OVERRIDES — or no client exists, which belongs in " + "_coverage.NO_BOTO3_CLIENT with its reason." ) - try: - response = getattr(client, xform_name(op))() - except ClientError as exc: - code = exc.response.get("Error", {}).get("Code") - if code in SERVED_ERROR_CODES: - # Served: the engine consulted an empty store and said so. + +def test_published_compatibility_tested_figure_matches_this_suite(): + """docs/coverage.md's fourth number is this suite's size, and is gated as such. + + The Go gate in cmd/devcloud/coverage_test.go checks the three numbers it can + see from the binary. This one is only visible from here, because it is a + fact about what botocore can address, so it is asserted here — same rule, + same both-directions failure. + """ + doc = ( + pathlib.Path(__file__).resolve().parents[2] / "docs" / "coverage.md" + ).read_text() + + rows = re.findall( + r"^\|\s*\*\*Compatibility-tested\*\*\s*\|[^|]*\|\s*\*\*(\d+)\*\*\s*\|", + doc, + re.M, + ) + assert len(rows) == 1, ( + f"docs/coverage.md: found {len(rows)} Compatibility-tested rows, want 1. " + "The summary table was restructured; this gate reads it." + ) + assert int(rows[0]) == len(TESTABLE_SERVICES), ( + f"docs/coverage.md publishes {rows[0]} compatibility-tested services, this " + f"suite exercises {len(TESTABLE_SERVICES)}. Excluded: " + f"{sorted(_coverage.NO_BOTO3_CLIENT)} (no boto3 client) and " + f"{sorted(_coverage.UNREACHABLE_FROM_BOTO3)} (unroutable)." + ) + + +def test_services_without_a_boto3_client_are_exactly_the_known_two(): + """The compatibility-tested ceiling is a fact about the SDK, not a backlog. + + docs/coverage.md publishes this ceiling. If the set changes, the published + number changes with it, so it is pinned here rather than counted at runtime. + """ + missing = {s for s in ALL_SERVICES if _coverage.boto3_name(s) is None} + assert missing == set(_coverage.NO_BOTO3_CLIENT), ( + f"services with no boto3 client changed: {sorted(missing)}. " + "docs/coverage.md publishes this set and its size." + ) + + +@pytest.mark.parametrize("service", sorted(_coverage.UNREACHABLE_FROM_BOTO3)) +def test_lex_services_are_unreachable_from_boto3(service_client, service): + """The four Lex services are registered, counted as served, and unroutable. + + All four boto3 Lex clients sign as "lex", no service is named "lex", so the + alias stays contested and unrouted rather than guessed. docs/coverage.md + said each Lex service is reachable "by its own unambiguous name"; a boto3 + caller has no such name to use, which is what this pins. + + It asserts UnknownService deliberately. Making Lex routable is routing work, + not coverage work, and when it lands this test fails — which is the signal to + move these four into the parametrization above and raise the published + compatibility-tested figure with them. + """ + entry = MANIFEST[service] + name = _coverage.boto3_name(service) + client = service_client(name) + + candidates = _coverage.probe_operations(name, entry["servedOps"]) + assert candidates, f"{service} has no served operation to probe" + operation, needs_input = candidates[0] + params = _coverage.stub_params(name, operation) if needs_input else {} + + with pytest.raises(ClientError) as excinfo: + _call(client, operation, params) + + code = excinfo.value.response.get("Error", {}).get("Code") + assert code == "UnknownService", ( + f"{service} ({name}.{operation}) answered {code}, not UnknownService. " + "If Lex routing was fixed, move these services into " + "test_registered_service_meets_the_floor and update docs/coverage.md." + ) + + +@pytest.mark.parametrize("service", TESTABLE_SERVICES) +def test_registered_service_meets_the_floor(service_client, service): + """The floor, for every registered service, in one assertion per service. + + The manifest decides which half applies. A service that serves something is + asked for one of the operations it serves; a service that serves nothing is + asked for anything at all and must refuse in AWS's vocabulary. + """ + entry = MANIFEST[service] + name = _coverage.boto3_name(service) + client = service_client(name) + + candidates = _coverage.probe_operations(name, entry["servedOps"]) + + if not candidates: + _assert_declines_cleanly(client, name, service, entry) + return + + # The floor is a property of the service, not of one operation: at least one + # operation the manifest calls served has to answer. Trying several is what + # keeps a single overstated operation from reading as a dead service — the + # manifest labels an operation hand-verified when a provider has a case + # clause for it, which is not the same as the gateway being able to route to + # it. See docs/coverage.md. + refusals = [] + for operation, needs_input in candidates: + params = _coverage.stub_params(name, operation) if needs_input else {} + + try: + response = _call(client, operation, params) + except ParamValidationError as exc: + refusals.append(f"{operation}: request never left botocore ({exc})") + continue + except ClientError as exc: + code = exc.response.get("Error", {}).get("Code") + if not code or code in _coverage.UNSERVED_ERROR_CODES: + refusals.append(f"{operation}: {code or exc.response.get('Error')}") + continue + # Either a store that reported an absent resource honestly, or a + # validation refusal of the stub values. Both mean the request was + # routed and its operation classified, which is what this proves. return - pytest.fail( - f"{service}.{op} is routed but not served: {exc.response.get('Error')}. " - "The provider is most likely not returning plugin.ErrUnhandledOp, " - "so the request never reaches the CRUD engine." - ) + except Exception as exc: # noqa: BLE001 - the type is reported, not swallowed + # botocore could not parse the answer. That is a real defect, but an + # operation-level one: the service can still meet the floor on + # another operation, and calling it dead here would report the wrong + # thing. The type is kept so an all-candidates failure names it. + refusals.append( + f"{operation}: unparseable response ({type(exc).__name__}: {exc})" + ) + continue + + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 + return - assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 + pytest.fail( + f"{service} ({name}, {entry['protocol']}) serves nothing that answers. " + f"The fidelity manifest lists {len(entry['servedOps'])} served operations " + f"for it, and all {len(candidates)} tried were refused:\n " + + "\n ".join(refusals) + + "\nThe provider is most likely not returning plugin.ErrUnhandledOp, so " + "the request never reaches the CRUD engine." + ) -@pytest.mark.parametrize("service", REGISTERED_ONLY_SERVICES) -def test_registered_only_service_declines_cleanly(service_client, service): +def _assert_declines_cleanly(client, name, service, entry): """A service that serves nothing must say so in AWS's own vocabulary. This is the guarantee that keeps breadth from becoming a lie. Registering a service DevCloud cannot serve is worth doing — the call is routed and answered locally instead of silently reaching real AWS — but only while the - answer is an honest error. A fabricated 200 here would be worse than not - registering the service at all, because the caller would believe it. + answer is an honest error. """ - client = service_client(service) - - op = _parameterless_read_op(client) - if op is None: - pytest.skip(f"{service} declares no parameterless List*/Describe* operation") + model = _coverage.service_model(name) + operation = sorted(model.operation_names)[0] + params = _coverage.stub_params(name, operation) try: - response = getattr(client, xform_name(op))() + response = _call(client, operation, params) + except ParamValidationError as exc: + pytest.fail( + f"{service} ({name}.{operation}): the request never left botocore: {exc}. " + "This is a harness gap, not a service defect." + ) except ClientError as exc: error = exc.response["Error"] assert error.get("Code"), ( - f"{service}.{op} failed without an AWS error code: {error}" + f"{service} ({name}.{operation}) failed without an AWS error code: {error}" ) return pytest.fail( - f"{service}.{op} returned {response['ResponseMetadata']['HTTPStatusCode']} " - f"but nothing serves this service — a success here is fabricated. " - f"If it is genuinely served now, move it to ENGINE_SERVED_SERVICES." + f"{service} ({name}.{operation}, {entry['protocol']}) returned " + f"{response['ResponseMetadata']['HTTPStatusCode']} but the fidelity " + "manifest says nothing serves this service — a success here is " + "fabricated. If it is genuinely served now, run `make codegen`: the " + "manifest is the source, and this test follows it." )